| blob | a47b3bd4cadd4c34bf729edc0156192062a9d56f |
1 /* stabs.c -- Parse stabs debugging information
2 Copyright (C) 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>.
5 This file is part of GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA. */
22 /* This file contains code which parses stabs debugging information.
23 The organization of this code is based on the gdb stabs reading
24 code. The job it does is somewhat different, because it is not
25 trying to identify the correct address for anything. */
27 #include <stdio.h>
28 #include <ctype.h>
37 /* Meaningless definition needs by aout64.h. FIXME. */
38 #define BYTES_IN_WORD 4
43 #ifndef DIR_SEPARATOR
44 #ifdef _WIN32
46 #else
48 #endif
49 #endif
51 /* The number of predefined XCOFF types. */
53 #define XCOFF_TYPE_COUNT 34
55 /* This structure is used as a handle so that the stab parsing doesn't
56 need to use any static variables. */
58 struct stab_handle
59 {
60 /* The BFD. */
62 /* True if this is stabs in sections. */
63 boolean sections;
64 /* The symbol table. */
66 /* The number of symbols. */
68 /* The accumulated file name string. */
70 /* The value of the last N_SO symbol. */
71 bfd_vma so_value;
72 /* The value of the start of the file, so that we can handle file
73 relative N_LBRAC and N_RBRAC symbols. */
74 bfd_vma file_start_offset;
75 /* The offset of the start of the function, so that we can handle
76 function relative N_LBRAC and N_RBRAC symbols. */
77 bfd_vma function_start_offset;
78 /* The version number of gcc which compiled the current compilation
79 unit, 0 if not compiled by gcc. */
81 /* Whether an N_OPT symbol was seen that was not generated by gcc,
82 so that we can detect the SunPRO compiler. */
83 boolean n_opt_found;
84 /* The main file name. */
86 /* A stack of unfinished N_BINCL files. */
88 /* A list of finished N_BINCL files. */
90 /* Whether we are inside a function or not. */
91 boolean within_function;
92 /* The address of the end of the function, used if we have seen an
93 N_FUN symbol while in a function. This is -1 if we have not seen
94 an N_FUN (the normal case). */
95 bfd_vma function_end;
96 /* The depth of block nesting. */
98 /* List of pending variable definitions. */
100 /* Number of files for which we have types. */
102 /* Lists of types per file. */
104 /* Predefined XCOFF types. */
106 /* Undefined tags. */
108 /* Set by parse_stab_type if it sees a structure defined as a cross
109 reference to itself. Reset by parse_stab_type otherwise. */
110 boolean self_crossref;
111 };
113 /* A list of these structures is used to hold pending variable
114 definitions seen before the N_LBRAC of a block. */
116 struct stab_pending_var
117 {
118 /* Next pending variable definition. */
120 /* Name. */
122 /* Type. */
123 debug_type type;
124 /* Kind. */
126 /* Value. */
127 bfd_vma val;
128 };
130 /* A list of these structures is used to hold the types for a single
131 file. */
133 struct stab_types
134 {
135 /* Next set of slots for this file. */
137 /* Types indexed by type number. */
138 #define STAB_TYPES_SLOTS (16)
140 };
142 /* We keep a list of undefined tags that we encounter, so that we can
143 fill them in if the tag is later defined. */
145 struct stab_tag
146 {
147 /* Next undefined tag. */
149 /* Tag name. */
151 /* Type kind. */
153 /* Slot to hold real type when we discover it. If we don't, we fill
154 in an undefined tag type. */
155 debug_type slot;
156 /* Indirect type we have created to point at slot. */
157 debug_type type;
158 };
164 static boolean parse_stab_string
166 static debug_type parse_stab_type
168 debug_type **));
169 static boolean parse_stab_type_number
171 static debug_type parse_stab_range_type
175 static debug_type parse_stab_sun_floating_type
178 static debug_type parse_stab_struct_type
181 static boolean parse_stab_baseclasses
183 static boolean parse_stab_struct_fields
185 boolean *));
186 static boolean parse_stab_cpp_abbrev
188 static boolean parse_stab_one_struct_field
191 static boolean parse_stab_members
194 static debug_type parse_stab_argtypes
197 static boolean parse_stab_tilde_field
200 static debug_type parse_stab_array_type
204 static boolean find_excl
206 static boolean stab_record_variable
212 static debug_type stab_find_type
214 static boolean stab_record_type
216 static debug_type stab_xcoff_builtin_type
218 static debug_type stab_find_tagged_type
224 /* Save a string in memory. */
230 {
237 }
239 /* Read a number from a string. */
241 static bfd_vma
245 {
257 {
258 /* If bfd_vma is larger than unsigned long, and the number is
259 meant to be negative, we have to make sure that we sign
260 extend properly. */
264 }
266 /* Note that even though strtoul overflowed, it should have set *pp
267 to the end of the number, which is where we want it. */
270 {
272 boolean neg;
275 boolean overflow;
276 bfd_vma v;
278 /* Our own version of strtoul, for a bfd_vma. */
286 {
289 }
293 {
295 {
298 }
299 else
300 {
303 }
304 }
312 {
322 else
329 {
332 }
333 }
336 {
340 }
341 }
343 /* If we get here, the number is too large to represent in a
344 bfd_vma. */
348 else
352 }
354 /* Give an error for a bad stab string. */
356 static void
359 {
361 }
363 /* Warn about something in a stab string. */
365 static void
369 {
371 }
373 /* Create a handle to parse stabs symbols with. */
375 /*ARGSUSED*/
376 PTR
378 PTR dhandle;
380 boolean sections;
383 {
397 }
399 /* When we have processed all the stabs information, we need to go
400 through and fill in all the undefined tags. */
402 boolean
404 PTR dhandle;
405 PTR handle;
406 {
411 {
417 }
420 {
429 }
432 }
434 /* Handle a single stabs symbol. */
436 boolean
438 PTR dhandle;
439 PTR handle;
442 bfd_vma value;
444 {
447 /* gcc will emit two N_SO strings per compilation unit, one for the
448 directory name and one for the file name. We just collect N_SO
449 strings as we see them, and start the new compilation unit when
450 we see a non N_SO symbol. */
453 {
461 /* Generally, for stabs in the symbol table, the N_LBRAC and
462 N_RBRAC symbols are relative to the N_SO symbol value. */
466 /* We need to reset the mapping from type numbers to types. We
467 can't free the old mapping, because of the use of
468 debug_make_indirect_type. */
476 /* Now process whatever type we just got. */
477 }
480 {
486 /* Ignore extra outermost context from SunPRO cc and acc. */
491 {
494 }
496 /* Start an inner lexical block. */
498 (value
503 /* Emit any pending variable definitions. */
511 /* Ignore extra outermost context from SunPRO cc and acc. */
515 /* We shouldn't have any pending variable definitions here, but,
516 if we do, we probably need to emit them before closing the
517 block. */
521 /* End an inner lexical block. */
523 (value
530 {
533 }
537 /* This always ends a function. */
539 {
540 bfd_vma endval;
552 }
554 /* An empty string is emitted by gcc at the end of a compilation
555 unit. */
559 /* Just accumulate strings until we see a non N_SO symbol. If
560 the string starts with a directory separator or some other
561 form of absolute path specification, we discard the previously
562 accumulated strings. */
565 else
566 {
578 else
582 }
589 /* Start an include file. */
595 /* Start an include file which may be replaced. */
602 /* End an N_BINCL include. */
608 /* This is a duplicate of a header file named by N_BINCL which
609 was eliminated by the linker. */
632 {
634 {
635 /* This always marks the end of a function; we don't
636 need to worry about info->function_end. */
644 }
646 }
648 /* A const static symbol in the .text section will have an N_FUN
649 entry. We need to use these to mark the end of the function,
650 in case we are looking at gcc output before it was changed to
651 always emit an empty N_FUN. We can't call debug_end_function
652 here, because it might be a local static symbol. */
658 /* Fall through. */
659 /* FIXME: gdb checks the string for N_STSYM, N_LCSYM or N_ROSYM
660 symbols, and if it does not start with :S, gdb relocates the
661 value to the start of the section. gcc always seems to use
662 :S, so we don't worry about this. */
663 /* Fall through. */
665 {
671 {
673 {
674 bfd_vma endval;
684 }
685 /* For stabs in sections, line numbers and block addresses
686 are offsets from the start of the function. */
690 }
694 }
702 else
710 }
713 }
715 /* Parse the stabs string. */
717 static boolean
719 PTR dhandle;
723 bfd_vma value;
725 {
729 debug_type dtype;
730 boolean synonym;
731 boolean self_crossref;
740 {
744 {
747 }
748 }
750 /* GCC 2.x puts the line number in desc. SunOS apparently puts in
751 the number of bytes occupied by a type or object, which we
752 ignore. */
755 else
758 /* FIXME: Sometimes the special C++ names start with '.'. */
761 {
763 {
768 /* Was: name = "vptr"; */
774 /* This was an anonymous type that was never fixed up. */
777 /* SunPRO (3.0 at least) static variable encoding. */
782 }
783 }
786 {
789 else
791 }
796 else
800 {
802 /* c is a special case, not followed by a type-number.
803 SYMBOL:c=iVALUE for an integer constant symbol.
804 SYMBOL:c=rVALUE for a floating constant symbol.
805 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
806 e.g. "b:c=e6,0" for "const b = blob1"
807 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
809 {
812 }
815 {
817 /* Floating point constant. */
822 /* Integer constant. */
823 /* Defining integer constants this way is kind of silly,
824 since 'e' constants allows the compiler to give not only
825 the value, but the type as well. C has at least int,
826 long, unsigned int, and long long as constant types;
827 other languages probably should have at least unsigned as
828 well as signed constants. */
833 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
834 can be represented as integral.
835 e.g. "b:c=e6,0" for "const b = blob1"
836 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
842 {
845 }
852 }
857 /* The name of a caught exception. */
868 /* A function definition. */
876 /* Sun acc puts declared types of arguments here. We don't care
877 about their actual types (FIXME -- we should remember the whole
878 function prototype), but the list may define some new types
879 that we have to remember, so we must scan it now. */
881 {
887 }
892 {
897 /* A global symbol. The value must be extracted from the
898 symbol table. */
905 {
913 }
917 value))
919 }
922 /* This case is faked by a conditional above, when there is no
923 code letter in the dbx data. Dbx data never actually
924 contains 'l'. */
932 value))
937 /* A function parameter. */
941 else
942 {
943 /* pF is a two-letter code that means a function parameter in
944 Fortran. The type-number specifies the type of the return
945 value. Translate it into a pointer-to-function type. */
950 {
951 debug_type ftype;
956 }
957 }
961 value))
964 /* FIXME: At this point gdb considers rearranging the parameter
965 address on a big endian machine if it is smaller than an int.
966 We have no way to do that, since we don't really know much
967 about the target. */
973 {
974 /* Prototype of a function referenced by this file. */
976 {
982 }
984 }
985 /* Fall through. */
987 /* Parameter which is in a register. */
993 value))
998 /* Register variable (either global or local). */
1004 value))
1007 /* FIXME: At this point gdb checks to combine pairs of 'p' and
1008 'r' stabs into a single 'P' stab. */
1013 /* Static symbol at top level of file */
1019 value))
1024 /* A typedef. */
1029 {
1030 /* A nameless type. Nothing to do. */
1032 }
1044 /* Struct, union, or enum tag. For GNU C++, this can be be followed
1045 by 't' which means we are typedef'ing it as well. */
1047 {
1049 /* FIXME: gdb sets synonym to true if the current language
1050 is C++. */
1051 }
1052 else
1053 {
1056 }
1064 /* INFO->SELF_CROSSREF is set by parse_stab_type if this type is
1065 a cross reference to itself. These are generated by some
1066 versions of g++. */
1075 /* See if we have a cross reference to this tag which we can now
1076 fill in. Avoid filling in a cross reference to ourselves,
1077 because that would lead to circular debugging information. */
1079 {
1083 {
1086 {
1090 }
1091 }
1092 }
1095 {
1102 }
1107 /* Static symbol of local scope */
1112 /* FIXME: gdb checks os9k_stabs here. */
1119 /* Reference parameter. */
1125 value))
1130 /* Reference parameter which is in a register. */
1136 value))
1141 /* This is used by Sun FORTRAN for "function result value".
1142 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1143 that Pascal uses it too, but when I tried it Pascal used
1144 "x:3" (local symbol) instead. */
1150 value))
1157 }
1159 /* FIXME: gdb converts structure values to structure pointers in a
1160 couple of cases, depending upon the target. */
1163 }
1165 /* Parse a stabs type. The typename argument is non-NULL if this is a
1166 typedef or a tag definition. The pp argument points to the stab
1167 string, and is updated. The slotp argument points to a place to
1168 store the slot used if the type is being defined. */
1170 static debug_type
1172 PTR dhandle;
1177 {
1181 boolean stringp;
1183 debug_type dtype;
1195 /* Read type number if present. The type number may be omitted.
1196 for instance in a two-dimensional array declared with type
1197 "ar1;1;10;ar1;1;10;4". */
1199 {
1200 /* 'typenums=' not present, type is anonymous. Read and return
1201 the definition, but don't put it in the type vector. */
1203 }
1204 else
1205 {
1210 {
1211 /* Type is not being defined here. Either it already
1212 exists, or this is a forward reference to it. */
1214 }
1216 /* Only set the slot if the type is being defined. This means
1217 that the mapping from type numbers to types will only record
1218 the name of the typedef which defines a type. If we don't do
1219 this, then something like
1220 typedef int foo;
1221 int i;
1222 will record that i is of type foo. Unfortunately, stabs
1223 information is ambiguous about variable types. For this code,
1224 typedef int foo;
1225 int i;
1226 foo j;
1227 the stabs information records both i and j as having the same
1228 type. This could be fixed by patching the compiler. */
1232 /* Type is being defined here. */
1233 /* Skip the '='. */
1237 {
1242 {
1243 /* Member type. */
1245 }
1247 /* Type attributes. */
1251 {
1253 {
1256 }
1257 }
1261 {
1273 /* Ignore unrecognized type attributes, so future
1274 compilers can invent new ones. */
1276 }
1277 }
1278 }
1284 {
1286 {
1290 /* A cross reference to another type. */
1293 {
1304 /* Complain and keep going, so compilers can invent new
1305 cross-reference types. */
1309 }
1315 {
1318 }
1320 {
1327 {
1330 }
1331 }
1333 /* Some versions of g++ can emit stabs like
1334 fleep:T20=xsfleep:
1335 which define structures in terms of themselves. We need to
1336 tell the caller to avoid building a circular structure. */
1345 }
1360 {
1364 /* This type is defined as another type. */
1369 /* Peek ahead at the number to detect void. */
1374 {
1375 /* This type is being defined as itself, which means that
1376 it is void. */
1378 }
1379 else
1380 {
1383 /* Go back to the number and have parse_stab_type get it.
1384 This means that we can deal with something like
1385 t(1,2)=(3,4)=... which the Lucid compiler uses. */
1390 }
1393 {
1396 }
1399 }
1405 pp,
1410 /* Reference to another type. */
1411 dtype = (debug_make_reference_type
1418 /* Function returning another type. */
1419 /* FIXME: gdb checks os9k_stabs here. */
1420 dtype = (debug_make_function_type
1428 /* Const qualifier on some type (Sun). */
1429 /* FIXME: gdb accepts 'c' here if os9k_stabs. */
1433 pp,
1438 /* Volatile qual on some type (Sun). */
1439 /* FIXME: gdb accepts 'i' here if os9k_stabs. */
1440 dtype = (debug_make_volatile_type
1447 /* Offset (class & variable) type. This is used for a pointer
1448 relative to an object. */
1449 {
1450 debug_type domain;
1451 debug_type memtype;
1453 /* Member type. */
1461 {
1464 }
1473 }
1477 /* Method (class & fn) type. */
1479 {
1480 debug_type return_type;
1488 {
1491 }
1494 DEBUG_TYPE_NULL,
1496 }
1497 else
1498 {
1499 debug_type domain;
1500 debug_type return_type;
1504 boolean varargs;
1512 {
1515 }
1527 {
1529 {
1532 }
1536 {
1540 }
1547 }
1550 /* If the last type is not void, then this function takes a
1551 variable number of arguments. Otherwise, we must strip
1552 the void type. */
1556 else
1557 {
1560 }
1565 varargs);
1566 }
1570 /* Range type. */
1575 /* FIXME: gdb checks os9k_stabs here. */
1576 /* Sun ACC builtin int type. */
1581 /* Sun ACC builtin float type. */
1586 /* Enumeration type. */
1592 /* Struct or union type. */
1598 /* Array type. */
1600 {
1603 }
1613 pp,
1615 stringp);
1621 }
1627 {
1630 }
1633 {
1636 }
1639 }
1641 /* Read a number by which a type is referred to in dbx data, or
1642 perhaps read a pair (FILENUM, TYPENUM) in parentheses. Just a
1643 single number N is equivalent to (0,N). Return the two numbers by
1644 storing them in the vector TYPENUMS. */
1646 static boolean
1650 {
1656 {
1659 }
1660 else
1661 {
1665 {
1668 }
1672 {
1675 }
1677 }
1680 }
1682 /* Parse a range type. */
1684 static debug_type
1686 PTR dhandle;
1691 {
1694 boolean self_subrange;
1695 debug_type index_type;
1704 /* First comes a type we are a subrange of.
1705 In C it is usually 0, 1 or the type being defined. */
1713 {
1719 }
1724 /* The remaining two operands are usually lower and upper bounds of
1725 the range. But in some special cases they mean something else. */
1729 {
1732 }
1738 {
1741 }
1745 {
1746 /* gcc will emit range stabs for long long types. Handle this
1747 as a special case. FIXME: This needs to be more general. */
1752 {
1760 }
1763 }
1766 {
1767 /* A type defined as a subrange of itself, with both bounds 0,
1768 is void. */
1772 /* A type defined as a subrange of itself, with n2 positive and
1773 n3 zero, is a complex type, and n2 is the number of bytes. */
1777 /* If n3 is zero and n2 is positive, this is a floating point
1778 type, and n2 is the number of bytes. */
1782 /* If the upper bound is -1, this is an unsigned int. */
1784 {
1785 /* When gcc is used with -gstabs, but not -gstabs+, it will emit
1786 long long int:t6=r1;0;-1;
1787 long long unsigned int:t7=r1;0;-1;
1788 We hack here to handle this reasonably. */
1790 {
1795 }
1796 /* FIXME: The size here really depends upon the target. */
1798 }
1800 /* A range of 0 to 127 is char. */
1804 /* FIXME: gdb checks for the language CHILL here. */
1807 {
1816 #ifdef BFD64
1819 #endif
1820 }
1826 {
1833 #ifdef BFD64
1836 #endif
1837 }
1838 }
1840 /* At this point I don't have the faintest idea how to deal with a
1841 self_subrange type; I'm going to assume that this is used as an
1842 idiom, and that all of them are special cases. So . . . */
1844 {
1847 }
1851 {
1852 /* Does this actually ever happen? Is that why we are worrying
1853 about dealing with it rather than just calling error_type? */
1856 }
1859 }
1861 /* Sun's ACC uses a somewhat saner method for specifying the builtin
1862 typedefs in every file (for int, long, etc):
1864 type = b <signed> <width>; <offset>; <nbits>
1865 signed = u or s. Possible c in addition to u or s (for char?).
1866 offset = offset from high order bit to start bit of type.
1867 width is # bytes in object of this type, nbits is # bits in type.
1869 The width/offset stuff appears to be for small objects stored in
1870 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
1871 FIXME. */
1873 static debug_type
1875 PTR dhandle;
1877 {
1879 boolean unsignedp;
1880 bfd_vma bits;
1885 {
1895 }
1898 /* For some odd reason, all forms of char put a c here. This is strange
1899 because no other type has this honor. We can safely ignore this because
1900 we actually determine 'char'acterness by the number of bits specified in
1901 the descriptor. */
1905 /* The first number appears to be the number of bytes occupied
1906 by this type, except that unsigned short is 4 instead of 2.
1907 Since this information is redundant with the third number,
1908 we will ignore it. */
1911 {
1914 }
1917 /* The second number is always 0, so ignore it too. */
1920 {
1923 }
1926 /* The third number is the number of bits for this type. */
1929 /* The type *should* end with a semicolon. If it are embedded
1930 in a larger type the semicolon may be the only way to know where
1931 the type ends. If this type is at the end of the stabstring we
1932 can deal with the omitted semicolon (but we don't have to like
1933 it). Don't bother to complain(), Sun's compiler omits the semicolon
1934 for "void". */
1942 }
1944 /* Parse a builtin floating type generated by the Sun compiler. */
1946 static debug_type
1948 PTR dhandle;
1950 {
1952 bfd_vma details;
1953 bfd_vma bytes;
1957 /* The first number has more details about the type, for example
1958 FN_COMPLEX. */
1961 {
1964 }
1966 /* The second number is the number of bytes occupied by this type */
1969 {
1972 }
1980 }
1982 /* Handle an enum type. */
1984 static debug_type
1986 PTR dhandle;
1988 {
1997 /* FIXME: gdb checks os9k_stabs here. */
1999 /* The aix4 compiler emits an extra field before the enum members;
2000 my guess is it's a type of some sort. Just ignore it. */
2002 {
2006 }
2008 /* Read the value-names and their values.
2009 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
2010 A semicolon or comma instead of a NAME means the end. */
2016 {
2019 bfd_signed_vma val;
2030 {
2033 }
2037 {
2043 }
2048 }
2057 }
2059 /* Read the description of a structure (or union type) and return an object
2060 describing the type.
2062 PP points to a character pointer that points to the next unconsumed token
2063 in the the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
2064 *PP will point to "4a:1,0,32;;". */
2066 static debug_type
2068 PTR dhandle;
2072 boolean structp;
2074 {
2076 bfd_vma size;
2079 boolean statics;
2081 debug_type vptrbase;
2082 boolean ownvptr;
2086 /* Get the size. */
2089 /* Get the other information. */
2106 }
2108 /* The stabs for C++ derived classes contain baseclass information which
2109 is marked by a '!' character after the total size. This function is
2110 called when we encounter the baseclass marker, and slurps up all the
2111 baseclass information.
2113 Immediately following the '!' marker is the number of base classes that
2114 the class is derived from, followed by information for each base class.
2115 For each base class, there are two visibility specifiers, a bit offset
2116 to the base class information within the derived class, a reference to
2117 the type for the base class, and a terminating semicolon.
2119 A typical example, with two base classes, would be "!2,020,19;0264,21;".
2120 ^^ ^ ^ ^ ^ ^ ^
2121 Baseclass information marker __________________|| | | | | | |
2122 Number of baseclasses __________________________| | | | | | |
2123 Visibility specifiers (2) ________________________| | | | | |
2124 Offset in bits from start of class _________________| | | | |
2125 Type number for base class ___________________________| | | |
2126 Visibility specifiers (2) _______________________________| | |
2127 Offset in bits from start of class ________________________| |
2128 Type number of base class ____________________________________|
2130 Return true for success, false for failure. */
2132 static boolean
2134 PTR dhandle;
2138 {
2148 {
2149 /* No base classes. */
2151 }
2157 {
2160 }
2166 {
2169 bfd_vma bitpos;
2170 debug_type type;
2173 {
2184 }
2188 {
2202 }
2205 /* The remaining value is the bit offset of the portion of the
2206 object corresponding to this baseclass. Always zero in the
2207 absence of multiple inheritance. */
2210 {
2213 }
2222 visibility);
2229 }
2236 }
2238 /* Read struct or class data fields. They have the form:
2240 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2242 At the end, we see a semicolon instead of a field.
2244 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2245 a static field.
2247 The optional VISIBILITY is one of:
2249 '/0' (VISIBILITY_PRIVATE)
2250 '/1' (VISIBILITY_PROTECTED)
2251 '/2' (VISIBILITY_PUBLIC)
2252 '/9' (VISIBILITY_IGNORE)
2254 or nothing, for C style fields with public visibility.
2256 Returns 1 for success, 0 for failure. */
2258 static boolean
2260 PTR dhandle;
2265 {
2281 {
2282 /* FIXME: gdb checks os9k_stabs here. */
2286 /* Add 1 to c to leave room for NULL pointer at end. */
2288 {
2292 }
2294 /* If it starts with CPLUS_MARKER it is a special abbreviation,
2295 unless the CPLUS_MARKER is followed by an underscore, in
2296 which case it is just the name of an anonymous type, which we
2297 should handle like any other type name. We accept either '$'
2298 or '.', because a field name can never contain one of these
2299 characters except as a CPLUS_MARKER. */
2302 {
2308 }
2310 /* Look for the ':' that separates the field name from the field
2311 values. Data members are delimited by a single ':', while member
2312 functions are delimited by a pair of ':'s. When we hit the member
2313 functions (if any), terminate scan loop and return. */
2317 {
2320 }
2326 staticsp))
2330 }
2337 }
2339 /* Special GNU C++ name. */
2341 static boolean
2343 PTR dhandle;
2347 {
2350 debug_type context;
2353 debug_type type;
2354 bfd_vma bitpos;
2361 {
2364 }
2370 /* At this point, *pp points to something like "22:23=*22...", where
2371 the type number before the ':' is the "context" and everything
2372 after is a regular type definition. Lookup the type, find it's
2373 name, and construct the field name. */
2381 {
2383 /* $vf -- a virtual function table pointer. */
2387 /* $vb -- a virtual bsomethingorother */
2390 {
2393 }
2400 }
2403 {
2406 }
2412 {
2415 }
2420 {
2423 }
2427 DEBUG_VISIBILITY_PRIVATE);
2432 }
2434 /* Parse a single field in a struct or union. */
2436 static boolean
2438 PTR dhandle;
2444 {
2448 debug_type type;
2449 bfd_vma bitpos;
2450 bfd_vma bitsize;
2454 /* FIXME: gdb checks ARM_DEMANGLING here. */
2462 else
2463 {
2466 {
2480 }
2482 }
2490 {
2493 /* This is a static class member. */
2497 {
2500 }
2507 visibility);
2511 }
2514 {
2517 }
2522 {
2525 }
2530 {
2533 }
2537 {
2538 /* This can happen in two cases: (1) at least for gcc 2.4.5 or
2539 so, it is a field which has been optimized out. The correct
2540 stab for this case is to use VISIBILITY_IGNORE, but that is a
2541 recent invention. (2) It is a 0-size array. For example
2542 union { int num; char str[0]; } foo. Printing "<no value>"
2543 for str in "p foo" is OK, since foo.str (and thus foo.str[3])
2544 will continue to work, and a 0-size array as a whole doesn't
2545 have any contents to print.
2547 I suspect this probably could also happen with gcc -gstabs
2548 (not -gstabs+) for static fields, and perhaps other C++
2549 extensions. Hopefully few people use -gstabs with gdb, since
2550 it is intended for dbx compatibility. */
2552 }
2554 /* FIXME: gdb does some stuff here to mark fields as unpacked. */
2559 }
2561 /* Read member function stabs info for C++ classes. The form of each member
2562 function data is:
2564 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2566 An example with two member functions is:
2568 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2570 For the case of overloaded operators, the format is op$::*.funcs, where
2571 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2572 name (such as `+=') and `.' marks the end of the operator name. */
2574 static boolean
2576 PTR dhandle;
2582 {
2597 {
2603 debug_type look_ahead_type;
2609 /* FIXME: Some systems use something other than '$' here. */
2611 {
2614 }
2615 else
2616 {
2617 /* This is a completely wierd case. In order to stuff in the
2618 names that might contain colons (the usual name delimiter),
2619 Mike Tiemann defined a different name format which is
2620 signalled if the identifier is "op$". In that case, the
2621 format is "op$::XXXX." where XXXX is the name. This is
2622 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2625 ;
2627 {
2630 }
2633 }
2642 do
2643 {
2644 debug_type type;
2645 boolean stub;
2649 bfd_vma voffset;
2650 debug_type context;
2652 boolean varargs;
2655 {
2656 /* g++ version 1 kludge */
2659 }
2660 else
2661 {
2667 {
2670 }
2671 }
2676 {
2679 }
2690 {
2700 }
2706 {
2708 /* Normal function. */
2712 /* const member function. */
2717 /* volatile member function. */
2722 /* const volatile member function. */
2730 /* File compiled with g++ version 1; no information. */
2735 }
2739 {
2741 /* virtual member function, followed by index. The sign
2742 bit is supposedly set to distinguish
2743 pointers-to-methods from virtual function indicies. */
2747 {
2750 }
2755 {
2756 /* Must be g++ version 1. */
2758 }
2759 else
2760 {
2761 /* Figure out from whence this virtual function
2762 came. It may belong to virtual function table of
2763 one of its baseclasses. */
2766 pp,
2769 {
2770 /* g++ version 1 overloaded methods. */
2772 }
2773 else
2774 {
2778 {
2781 }
2783 }
2784 }
2788 /* static member function. */
2808 }
2810 /* If the type is not a stub, then the argtypes string is
2811 the physical name of the function. Otherwise the
2812 argtypes string is the mangled form of the argument
2813 types, and the full type and the physical name must be
2814 extracted from them. */
2817 else
2818 {
2826 {
2829 }
2835 }
2838 {
2843 }
2850 else
2852 physname,
2853 type,
2854 visibility,
2855 constp,
2856 volatilep);
2861 }
2870 {
2874 }
2879 }
2887 }
2889 /* Parse a string representing argument types for a method. Stabs
2890 tries to save space by packing argument types into a mangled
2891 string. This string should give us enough information to extract
2892 both argument types and the physical name of the function, given
2893 the tag name. */
2895 static debug_type
2898 PTR dhandle;
2900 debug_type class_type;
2903 debug_type return_type;
2905 boolean constp;
2906 boolean volatilep;
2908 {
2909 boolean is_full_physname_constructor;
2910 boolean is_constructor;
2911 boolean is_destructor;
2913 boolean varargs;
2915 /* Constructors are sometimes handled specially. */
2923 is_constructor = (is_full_physname_constructor
2933 else
2934 {
2949 {
2950 /* Template methods are fully mangled. */
2954 }
2955 else
2960 + len
2967 {
2972 {
2975 }
2980 }
2981 else
2982 {
2986 else
2988 }
2996 }
2999 {
3004 }
3011 varargs);
3012 }
3014 /* The tail end of stabs for C++ classes that contain a virtual function
3015 pointer contains a tilde, a %, and a type number.
3016 The type number refers to the base class (possibly this class itself) which
3017 contains the vtable pointer for the current class.
3019 This function is called when we have parsed all the method declarations,
3020 so we can look for the vptr base class info. */
3022 static boolean
3024 PTR dhandle;
3030 {
3040 /* If we are positioned at a ';', then skip it. */
3050 {
3051 /* Obsolete flags that used to indicate the presence of
3052 constructors and/or destructors. */
3054 }
3063 /* The next number is the type number of the base class (possibly
3064 our own class) which supplies the vtable for this class. */
3071 else
3072 {
3073 debug_type vtype;
3081 ;
3083 {
3086 }
3091 }
3094 }
3096 /* Read a definition of an array type. */
3098 static debug_type
3100 PTR dhandle;
3103 boolean stringp;
3104 {
3108 debug_type index_type;
3109 boolean adjustable;
3111 debug_type element_type;
3113 /* Format of an array type:
3114 "ar<index type>;lower;upper;<array_contents_type>".
3115 OS9000: "arlower,upper;<array_contents_type>".
3117 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3118 for these, produce a type like float[][]. */
3122 /* FIXME: gdb checks os9k_stabs here. */
3124 /* If the index type is type 0, we take it as int. */
3129 {
3132 {
3136 }
3138 }
3139 else
3140 {
3143 }
3146 {
3149 }
3155 {
3158 }
3162 {
3165 }
3169 {
3172 }
3176 {
3179 }
3188 {
3191 }
3195 }
3197 /* This struct holds information about files we have seen using
3198 N_BINCL. */
3200 struct bincl_file
3201 {
3202 /* The next N_BINCL file. */
3204 /* The next N_BINCL on the stack. */
3206 /* The file name. */
3208 /* The hash value. */
3209 bfd_vma hash;
3210 /* The file index. */
3212 /* The list of types defined in this file. */
3214 };
3216 /* Start a new N_BINCL file, pushing it onto the stack. */
3218 static void
3222 bfd_vma hash;
3223 {
3242 }
3244 /* Finish an N_BINCL file, at an N_EINCL, popping the name off the
3245 stack. */
3250 {
3263 }
3265 /* Handle an N_EXCL: get the types from the corresponding N_BINCL. */
3267 static boolean
3271 bfd_vma hash;
3272 {
3285 {
3289 }
3294 }
3296 /* Handle a variable definition. gcc emits variable definitions for a
3297 block before the N_LBRAC, so we must hold onto them until we see
3298 it. The SunPRO compiler emits variable definitions after the
3299 N_LBRAC, so we can call debug_record_variable immediately. */
3301 static boolean
3303 PTR dhandle;
3306 debug_type type;
3308 bfd_vma val;
3309 {
3328 }
3330 /* Emit pending variable definitions. This is called after we see the
3331 N_LBRAC that starts the block. */
3333 static boolean
3335 PTR dhandle;
3337 {
3342 {
3351 }
3356 }
3358 /* Find the slot for a type in the database. */
3364 {
3373 {
3376 }
3378 {
3381 }
3386 {
3388 {
3391 }
3394 }
3396 {
3399 }
3402 }
3404 /* Find a type given a type number. If the type has not been
3405 allocated yet, create an indirect type. */
3407 static debug_type
3409 PTR dhandle;
3412 {
3416 {
3417 /* A negative type number indicates an XCOFF builtin type. */
3419 }
3429 }
3431 /* Record that a given type number refers to a given type. */
3433 static boolean
3435 PTR dhandle;
3438 debug_type type;
3439 {
3446 /* gdb appears to ignore type redefinitions, so we do as well. */
3451 }
3453 /* Return an XCOFF builtin type. */
3455 static debug_type
3457 PTR dhandle;
3460 {
3461 debug_type rettype;
3465 {
3468 }
3473 {
3475 /* The size of this and all the other types are fixed, defined
3476 by the debugging format. */
3520 /* IEEE single precision (32 bit). */
3525 /* IEEE double precision (64 bit). */
3530 /* This is an IEEE double on the RS/6000, and different machines
3531 with different sizes for "long double" should use different
3532 negative type numbers. See stabs.texinfo. */
3553 /* FIXME */
3558 /* FIXME */
3579 /* Complex type consisting of two IEEE single precision values. */
3584 /* Complex type consisting of two IEEE double precision values. */
3601 /* FIXME */
3623 }
3630 }
3632 /* Find or create a tagged type. */
3634 static debug_type
3636 PTR dhandle;
3641 {
3643 debug_type dtype;
3648 /* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same
3649 namespace. This is right for C, and I don't know how to handle
3650 other languages. FIXME. */
3653 {
3656 }
3658 /* We need to allocate an entry on the undefined tag list. */
3660 {
3663 {
3668 }
3669 }
3671 {
3681 }
3684 }
3685 \f
3686 /* In order to get the correct argument types for a stubbed method, we
3687 need to extract the argument types from a C++ mangled string.
3688 Since the argument types can refer back to the return type, this
3689 means that we must demangle the entire physical name. In gdb this
3690 is done by calling cplus_demangle and running the results back
3691 through the C++ expression parser. Since we have no expression
3692 parser, we must duplicate much of the work of cplus_demangle here.
3694 We assume that GNU style demangling is used, since this is only
3695 done for method stubs, and only g++ should output that form of
3696 debugging information. */
3698 /* This structure is used to hold a pointer to type information which
3699 demangling a string. */
3701 struct stab_demangle_typestring
3702 {
3703 /* The start of the type. This is not null terminated. */
3705 /* The length of the type. */
3707 };
3709 /* This structure is used to hold information while demangling a
3710 string. */
3712 struct stab_demangle_info
3713 {
3714 /* The debugging information handle. */
3715 PTR dhandle;
3716 /* The stab information handle. */
3718 /* The array of arguments we are building. */
3720 /* Whether the method takes a variable number of arguments. */
3721 boolean varargs;
3722 /* The array of types we have remembered. */
3724 /* The number of typestrings. */
3726 /* The number of typestring slots we have allocated. */
3728 };
3732 static boolean stab_demangle_get_count
3734 static boolean stab_demangle_prefix
3736 static boolean stab_demangle_function_name
3738 static boolean stab_demangle_signature
3740 static boolean stab_demangle_qualified
3742 static boolean stab_demangle_template
3744 static boolean stab_demangle_class
3746 static boolean stab_demangle_args
3748 boolean *));
3749 static boolean stab_demangle_arg
3752 static boolean stab_demangle_type
3754 static boolean stab_demangle_fund_type
3756 static boolean stab_demangle_remember_type
3759 /* Warn about a bad demangling. */
3761 static void
3764 {
3766 }
3768 /* Get a count from a stab string. */
3770 static unsigned int
3773 {
3778 {
3782 }
3784 }
3786 /* Require a count in a string. The count may be multiple digits, in
3787 which case it must end in an underscore. */
3789 static boolean
3793 {
3800 {
3806 do
3807 {
3811 }
3814 {
3817 }
3818 }
3821 }
3823 /* This function demangles a physical name, returning a NULL
3824 terminated array of argument types. */
3828 PTR dhandle;
3832 {
3845 /* cplus_demangle checks for special GNU mangled forms, but we can't
3846 see any of them in mangled method argument types. */
3852 {
3855 }
3866 error_return:
3870 }
3872 /* Demangle the prefix of the mangled name. */
3874 static boolean
3878 {
3882 /* cplus_demangle checks for global constructors and destructors,
3883 but we can't see them in mangled argument types. */
3885 /* Look for `__'. */
3887 do
3888 {
3890 }
3894 {
3897 }
3901 /* We found `__'; move ahead to the last contiguous `__' pair. */
3910 {
3911 /* This is a GNU style constructor name. */
3914 }
3918 {
3919 /* Look for the `__' that separates the prefix from the
3920 signature. */
3925 {
3928 }
3931 }
3933 {
3934 /* The name doesn't start with `__', but it does contain `__'. */
3936 }
3937 else
3938 {
3941 }
3942 /*NOTREACHED*/
3943 }
3945 /* Demangle a function name prefix. The scan argument points to the
3946 double underscore which separates the function name from the
3947 signature. */
3949 static boolean
3954 {
3957 /* The string from *pp to scan is the name of the function. We
3958 don't care about the name, since we just looking for argument
3959 types. However, for conversion operators, the name may include a
3960 type which we must remember in order to handle backreferences. */
3968 {
3971 /* This is a type conversion operator. */
3975 }
3980 {
3983 /* This is a type conversion operator. */
3987 }
3990 }
3992 /* Demangle the signature. This is where the argument types are
3993 found. */
3995 static boolean
3999 {
4011 {
4013 {
4024 /* Static member function. FIXME: Can this happen? */
4031 /* Const member function. */
4049 /* Function. I don't know if this actually happens with g++
4050 output. */
4059 /* Template. */
4070 /* At the outermost level, we cannot have a return type
4071 specified, so if we run into another '_' at this point we
4072 are dealing with a mangled name that is either bogus, or
4073 has been mangled by some algorithm we don't know how to
4074 deal with. So just reject the entire demangling. */
4079 /* Assume we have stumbled onto the first outermost function
4080 argument token, and start processing args. */
4085 }
4088 {
4092 }
4093 }
4096 {
4097 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
4098 bar__3fooi is 'foo::bar(int)'. We get here when we find the
4099 first case, and need to ensure that the '(void)' gets added
4100 to the current declp. */
4103 }
4106 }
4108 /* Demangle a qualified name, such as "Q25Outer5Inner" which is the
4109 mangled form of "Outer::Inner". */
4111 static boolean
4116 {
4120 debug_type context;
4125 {
4127 /* GNU mangled name with more than 9 classes. The count is
4128 preceded by an underscore (to distinguish it from the <= 9
4129 case) and followed by an underscore. */
4132 {
4135 }
4140 {
4143 }
4150 /* Skip an optional underscore after the count. */
4160 }
4164 /* Pick off the names. */
4166 {
4170 {
4178 {
4181 DEBUG_KIND_CLASS);
4185 }
4186 }
4187 else
4188 {
4193 {
4196 }
4199 {
4209 {
4212 /* Try to find the type by looking through the
4213 fields of context until we find a field with the
4214 same type. This ought to work for a class
4215 defined within a class, but it won't work for,
4216 e.g., an enum defined within a class. stabs does
4217 not give us enough information to figure out the
4218 latter case. */
4223 {
4224 debug_type ft;
4232 {
4235 }
4236 }
4239 }
4242 {
4243 /* We have to fall back on finding the type by name.
4244 If there are more types to come, then this must
4245 be a class. Otherwise, it could be anything. */
4248 {
4253 name);
4255 }
4258 {
4263 ? DEBUG_KIND_ILLEGAL
4267 }
4268 }
4269 }
4272 }
4273 }
4279 }
4281 /* Demangle a template. If PNAME is not NULL, this sets *PNAME to a
4282 string representation of the template. */
4284 static boolean
4289 {
4297 /* Skip the template name. */
4300 {
4303 }
4306 /* Get the size of the parameter list. */
4308 {
4311 }
4314 {
4316 {
4317 /* This is a type parameter. */
4321 }
4322 else
4323 {
4326 boolean done;
4336 /* This is a value parameter. */
4342 {
4344 {
4391 /* Assume it's a user defined integral type. */
4395 }
4396 }
4399 {
4404 }
4406 {
4413 {
4416 }
4417 }
4419 {
4424 {
4427 }
4428 }
4430 {
4436 {
4440 }
4442 {
4446 }
4447 }
4449 {
4453 {
4456 }
4458 }
4459 }
4460 }
4462 /* We can translate this to a string fairly easily by invoking the
4463 regular demangling routine. */
4465 {
4482 {
4487 }
4489 /* Eliminating all spaces, except those between > characters,
4490 makes it more likely that the demangled name will match the
4491 name which g++ used as the structure name. */
4500 }
4503 }
4505 /* Demangle a class name. */
4507 static boolean
4512 {
4520 {
4523 }
4531 }
4533 /* Demangle function arguments. If the pargs argument is not NULL, it
4534 is set to a NULL terminated array holding the arguments. */
4536 static boolean
4542 {
4550 {
4553 }
4557 {
4559 {
4568 else
4569 {
4571 {
4574 }
4575 }
4578 {
4581 }
4584 {
4587 }
4589 {
4595 }
4596 }
4597 else
4598 {
4601 }
4602 }
4608 {
4612 }
4615 }
4617 /* Demangle a single argument. */
4619 static boolean
4626 {
4628 debug_type type;
4637 {
4642 {
4646 }
4649 }
4652 }
4654 /* Demangle a type. If the ptype argument is not NULL, *ptype is set
4655 to the newly allocated type. */
4657 static boolean
4662 {
4668 {
4671 /* A pointer type. */
4680 /* A reference type. */
4689 /* An array. */
4690 {
4696 {
4698 {
4701 }
4705 }
4707 {
4710 }
4716 {
4717 debug_type int_type;
4724 }
4725 }
4729 /* A back reference to a remembered type. */
4730 {
4736 {
4739 }
4741 {
4744 }
4748 }
4752 /* A function. */
4753 {
4755 boolean varargs;
4767 {
4768 /* cplus_demangle will accept a function without a return
4769 type, but I don't know when that will happen, or what
4770 to do if it does. */
4773 }
4779 varargs);
4781 }
4786 {
4789 boolean varargs;
4801 {
4804 }
4807 {
4810 }
4815 {
4817 {
4820 }
4822 {
4825 }
4827 {
4830 }
4840 }
4843 {
4846 }
4853 {
4854 debug_type class_type;
4858 DEBUG_KIND_CLASS);
4865 else
4866 {
4867 /* FIXME: We have no way to record constp or
4868 volatilep. */
4871 }
4872 }
4873 }
4891 {
4897 }
4904 }
4907 }
4909 /* Demangle a fundamental type. If the ptype argument is not NULL,
4910 *ptype is set to the newly allocated type. */
4912 static boolean
4917 {
4920 boolean done;
4931 {
4933 {
4957 }
4958 }
4961 {
4964 /* cplus_demangle permits this, but I don't know what it means. */
4970 {
4974 }
4980 {
4982 (unsignedp
4987 }
4993 {
4995 (unsignedp
5000 }
5006 {
5008 (unsignedp
5013 }
5019 {
5021 (unsignedp
5026 }
5032 {
5036 }
5042 {
5044 (unsignedp
5046 : (signedp
5051 }
5057 {
5061 }
5067 {
5071 }
5077 {
5081 }
5087 {
5091 }
5098 {
5101 }
5102 /* Fall through. */
5105 {
5111 {
5118 {
5119 /* FIXME: It is probably incorrect to assume that
5120 undefined types are tagged types. */
5123 DEBUG_KIND_ILLEGAL);
5126 }
5127 }
5128 }
5132 {
5139 {
5142 DEBUG_KIND_CLASS);
5146 }
5147 }
5153 }
5156 {
5161 }
5164 }
5166 /* Remember a type string in a demangled string. */
5168 static boolean
5173 {
5175 {
5181 }
5188 }