| blob | 91eff59ffacef349d5253b2cb7ec6a9d20d4ad82 |
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
21 02111-1307, USA. */
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. */
28 #include <stdio.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. */
48 struct stab_handle
49 {
50 /* The BFD. */
52 /* TRUE if this is stabs in sections. */
53 bfd_boolean 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. */
61 bfd_vma so_value;
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. */
78 /* A list of finished N_BINCL files. */
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). */
85 bfd_vma function_end;
86 /* The depth of block nesting. */
88 /* List of pending variable definitions. */
90 /* Number of files for which we have types. */
92 /* Lists of types per file. */
94 /* Predefined XCOFF types. */
96 /* Undefined 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;
101 };
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
107 {
108 /* Next pending variable definition. */
110 /* Name. */
112 /* Type. */
113 debug_type type;
114 /* Kind. */
116 /* Value. */
117 bfd_vma val;
118 };
120 /* A list of these structures is used to hold the types for a single
121 file. */
123 struct stab_types
124 {
125 /* Next set of slots for this file. */
127 /* Types indexed by type number. */
128 #define STAB_TYPES_SLOTS (16)
130 };
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. */
135 struct stab_tag
136 {
137 /* Next undefined tag. */
139 /* Tag name. */
141 /* Type kind. */
143 /* Slot to hold real type when we discover it. If we don't, we fill
144 in an undefined tag type. */
145 debug_type slot;
146 /* Indirect type we have created to point at slot. */
147 debug_type type;
148 };
152 static bfd_vma parse_number
154 static void bad_stab
156 static void warn_stab
158 static bfd_boolean parse_stab_string
160 static debug_type parse_stab_type
162 debug_type **));
163 static bfd_boolean parse_stab_type_number
165 static debug_type parse_stab_range_type
168 static debug_type parse_stab_sun_builtin_type
170 static debug_type parse_stab_sun_floating_type
172 static debug_type parse_stab_enum_type
174 static debug_type parse_stab_struct_type
177 static bfd_boolean parse_stab_baseclasses
179 static bfd_boolean parse_stab_struct_fields
181 bfd_boolean *));
182 static bfd_boolean parse_stab_cpp_abbrev
184 static bfd_boolean parse_stab_one_struct_field
187 static bfd_boolean parse_stab_members
190 static debug_type parse_stab_argtypes
193 static bfd_boolean parse_stab_tilde_field
196 static debug_type parse_stab_array_type
198 static void push_bincl
202 static bfd_boolean find_excl
204 static bfd_boolean stab_record_variable
207 static bfd_boolean stab_emit_pending_vars
211 static debug_type stab_find_type
213 static bfd_boolean stab_record_type
215 static debug_type stab_xcoff_builtin_type
217 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. */
269 {
271 bfd_boolean neg;
274 bfd_boolean overflow;
275 bfd_vma v;
277 /* Our own version of strtoul, for a bfd_vma. */
284 {
287 }
291 {
293 {
296 }
297 else
298 {
301 }
302 }
310 {
320 else
327 {
330 }
331 }
334 {
338 }
339 }
341 /* If we get here, the number is too large to represent in a
342 bfd_vma. */
345 else
349 }
351 /* Give an error for a bad stab string. */
353 static void
356 {
358 }
360 /* Warn about something in a stab string. */
362 static void
366 {
368 }
370 /* Create a handle to parse stabs symbols with. */
372 PTR
374 PTR dhandle ATTRIBUTE_UNUSED;
376 bfd_boolean sections;
379 {
393 }
395 /* When we have processed all the stabs information, we need to go
396 through and fill in all the undefined tags. */
398 bfd_boolean
400 PTR dhandle;
401 PTR handle;
402 {
407 {
413 }
416 {
425 }
428 }
430 /* Handle a single stabs symbol. */
432 bfd_boolean
434 PTR dhandle;
435 PTR handle;
438 bfd_vma value;
440 {
443 /* gcc will emit two N_SO strings per compilation unit, one for the
444 directory name and one for the file name. We just collect N_SO
445 strings as we see them, and start the new compilation unit when
446 we see a non N_SO symbol. */
449 {
457 /* Generally, for stabs in the symbol table, the N_LBRAC and
458 N_RBRAC symbols are relative to the N_SO symbol value. */
462 /* We need to reset the mapping from type numbers to types. We
463 can't free the old mapping, because of the use of
464 debug_make_indirect_type. */
472 /* Now process whatever type we just got. */
473 }
476 {
482 /* Ignore extra outermost context from SunPRO cc and acc. */
487 {
490 }
492 /* Start an inner lexical block. */
494 (value
499 /* Emit any pending variable definitions. */
507 /* Ignore extra outermost context from SunPRO cc and acc. */
511 /* We shouldn't have any pending variable definitions here, but,
512 if we do, we probably need to emit them before closing the
513 block. */
517 /* End an inner lexical block. */
519 (value
526 {
529 }
533 /* This always ends a function. */
535 {
536 bfd_vma endval;
548 }
550 /* An empty string is emitted by gcc at the end of a compilation
551 unit. */
555 /* Just accumulate strings until we see a non N_SO symbol. If
556 the string starts with a directory separator or some other
557 form of absolute path specification, we discard the previously
558 accumulated strings. */
561 else
562 {
569 else
573 }
580 /* Start an include file. */
586 /* Start an include file which may be replaced. */
593 /* End an N_BINCL include. */
599 /* This is a duplicate of a header file named by N_BINCL which
600 was eliminated by the linker. */
624 {
626 {
627 /* This always marks the end of a function; we don't
628 need to worry about info->function_end. */
636 }
638 }
640 /* A const static symbol in the .text section will have an N_FUN
641 entry. We need to use these to mark the end of the function,
642 in case we are looking at gcc output before it was changed to
643 always emit an empty N_FUN. We can't call debug_end_function
644 here, because it might be a local static symbol. */
650 /* Fall through. */
651 /* FIXME: gdb checks the string for N_STSYM, N_LCSYM or N_ROSYM
652 symbols, and if it does not start with :S, gdb relocates the
653 value to the start of the section. gcc always seems to use
654 :S, so we don't worry about this. */
655 /* Fall through. */
657 {
663 {
665 {
666 bfd_vma endval;
676 }
677 /* For stabs in sections, line numbers and block addresses
678 are offsets from the start of the function. */
682 }
686 }
694 else
703 }
706 }
708 /* Parse the stabs string. */
710 static bfd_boolean
712 PTR dhandle;
716 bfd_vma value;
718 {
722 debug_type dtype;
723 bfd_boolean synonym;
724 bfd_boolean self_crossref;
733 {
737 {
740 }
741 }
743 /* GCC 2.x puts the line number in desc. SunOS apparently puts in
744 the number of bytes occupied by a type or object, which we
745 ignore. */
748 else
751 /* FIXME: Sometimes the special C++ names start with '.'. */
754 {
756 {
761 /* Was: name = "vptr"; */
767 /* This was an anonymous type that was never fixed up. */
770 /* SunPRO (3.0 at least) static variable encoding. */
775 }
776 }
779 {
782 else
784 }
789 else
793 {
795 /* c is a special case, not followed by a type-number.
796 SYMBOL:c=iVALUE for an integer constant symbol.
797 SYMBOL:c=rVALUE for a floating constant symbol.
798 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
799 e.g. "b:c=e6,0" for "const b = blob1"
800 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
802 {
805 }
808 {
810 /* Floating point constant. */
815 /* Integer constant. */
816 /* Defining integer constants this way is kind of silly,
817 since 'e' constants allows the compiler to give not only
818 the value, but the type as well. C has at least int,
819 long, unsigned int, and long long as constant types;
820 other languages probably should have at least unsigned as
821 well as signed constants. */
826 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
827 can be represented as integral.
828 e.g. "b:c=e6,0" for "const b = blob1"
829 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
835 {
838 }
845 }
850 /* The name of a caught exception. */
861 /* A function definition. */
869 /* Sun acc puts declared types of arguments here. We don't care
870 about their actual types (FIXME -- we should remember the whole
871 function prototype), but the list may define some new types
872 that we have to remember, so we must scan it now. */
874 {
880 }
885 {
890 /* A global symbol. The value must be extracted from the
891 symbol table. */
898 {
906 }
910 value))
912 }
915 /* This case is faked by a conditional above, when there is no
916 code letter in the dbx data. Dbx data never actually
917 contains 'l'. */
925 value))
930 /* A function parameter. */
934 else
935 {
936 /* pF is a two-letter code that means a function parameter in
937 Fortran. The type-number specifies the type of the return
938 value. Translate it into a pointer-to-function type. */
943 {
944 debug_type ftype;
949 }
950 }
954 value))
957 /* FIXME: At this point gdb considers rearranging the parameter
958 address on a big endian machine if it is smaller than an int.
959 We have no way to do that, since we don't really know much
960 about the target. */
965 {
966 /* Prototype of a function referenced by this file. */
968 {
974 }
976 }
977 /* Fall through. */
979 /* Parameter which is in a register. */
985 value))
990 /* Register variable (either global or local). */
996 value))
999 /* FIXME: At this point gdb checks to combine pairs of 'p' and
1000 'r' stabs into a single 'P' stab. */
1004 /* Static symbol at top level of file. */
1010 value))
1015 /* A typedef. */
1020 {
1021 /* A nameless type. Nothing to do. */
1023 }
1035 /* Struct, union, or enum tag. For GNU C++, this can be be followed
1036 by 't' which means we are typedef'ing it as well. */
1038 {
1040 /* FIXME: gdb sets synonym to TRUE if the current language
1041 is C++. */
1042 }
1043 else
1044 {
1047 }
1055 /* INFO->SELF_CROSSREF is set by parse_stab_type if this type is
1056 a cross reference to itself. These are generated by some
1057 versions of g++. */
1066 /* See if we have a cross reference to this tag which we can now
1067 fill in. Avoid filling in a cross reference to ourselves,
1068 because that would lead to circular debugging information. */
1070 {
1074 {
1077 {
1081 }
1082 }
1083 }
1086 {
1093 }
1098 /* Static symbol of local scope */
1103 /* FIXME: gdb checks os9k_stabs here. */
1110 /* Reference parameter. */
1116 value))
1121 /* Reference parameter which is in a register. */
1127 value))
1132 /* This is used by Sun FORTRAN for "function result value".
1133 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1134 that Pascal uses it too, but when I tried it Pascal used
1135 "x:3" (local symbol) instead. */
1141 value))
1148 }
1150 /* FIXME: gdb converts structure values to structure pointers in a
1151 couple of cases, depending upon the target. */
1154 }
1156 /* Parse a stabs type. The typename argument is non-NULL if this is a
1157 typedef or a tag definition. The pp argument points to the stab
1158 string, and is updated. The slotp argument points to a place to
1159 store the slot used if the type is being defined. */
1161 static debug_type
1163 PTR dhandle;
1168 {
1172 bfd_boolean stringp;
1174 debug_type dtype;
1186 /* Read type number if present. The type number may be omitted.
1187 for instance in a two-dimensional array declared with type
1188 "ar1;1;10;ar1;1;10;4". */
1190 {
1191 /* 'typenums=' not present, type is anonymous. Read and return
1192 the definition, but don't put it in the type vector. */
1194 }
1195 else
1196 {
1201 /* Type is not being defined here. Either it already
1202 exists, or this is a forward reference to it. */
1205 /* Only set the slot if the type is being defined. This means
1206 that the mapping from type numbers to types will only record
1207 the name of the typedef which defines a type. If we don't do
1208 this, then something like
1209 typedef int foo;
1210 int i;
1211 will record that i is of type foo. Unfortunately, stabs
1212 information is ambiguous about variable types. For this code,
1213 typedef int foo;
1214 int i;
1215 foo j;
1216 the stabs information records both i and j as having the same
1217 type. This could be fixed by patching the compiler. */
1221 /* Type is being defined here. */
1222 /* Skip the '='. */
1226 {
1231 /* Member type. */
1234 /* Type attributes. */
1238 {
1240 {
1243 }
1244 }
1248 {
1261 /* Ignore unrecognized type attributes, so future
1262 compilers can invent new ones. */
1264 }
1265 }
1266 }
1272 {
1274 {
1278 /* A cross reference to another type. */
1280 {
1291 /* Complain and keep going, so compilers can invent new
1292 cross-reference types. */
1296 }
1302 {
1305 }
1307 {
1311 {
1318 }
1321 {
1324 }
1325 }
1327 /* Some versions of g++ can emit stabs like
1328 fleep:T20=xsfleep:
1329 which define structures in terms of themselves. We need to
1330 tell the caller to avoid building a circular structure. */
1339 }
1354 {
1358 /* This type is defined as another type. */
1362 /* Peek ahead at the number to detect void. */
1367 {
1368 /* This type is being defined as itself, which means that
1369 it is void. */
1371 }
1372 else
1373 {
1376 /* Go back to the number and have parse_stab_type get it.
1377 This means that we can deal with something like
1378 t(1,2)=(3,4)=... which the Lucid compiler uses. */
1383 }
1386 {
1389 }
1392 }
1398 pp,
1403 /* Reference to another type. */
1404 dtype = (debug_make_reference_type
1411 /* Function returning another type. */
1412 /* FIXME: gdb checks os9k_stabs here. */
1413 dtype = (debug_make_function_type
1421 /* Const qualifier on some type (Sun). */
1422 /* FIXME: gdb accepts 'c' here if os9k_stabs. */
1426 pp,
1431 /* Volatile qual on some type (Sun). */
1432 /* FIXME: gdb accepts 'i' here if os9k_stabs. */
1433 dtype = (debug_make_volatile_type
1440 /* Offset (class & variable) type. This is used for a pointer
1441 relative to an object. */
1442 {
1443 debug_type domain;
1444 debug_type memtype;
1446 /* Member type. */
1454 {
1457 }
1466 }
1470 /* Method (class & fn) type. */
1472 {
1473 debug_type return_type;
1481 {
1484 }
1487 DEBUG_TYPE_NULL,
1489 }
1490 else
1491 {
1492 debug_type domain;
1493 debug_type return_type;
1497 bfd_boolean varargs;
1505 {
1508 }
1520 {
1522 {
1525 }
1529 {
1533 }
1540 }
1543 /* If the last type is not void, then this function takes a
1544 variable number of arguments. Otherwise, we must strip
1545 the void type. */
1549 else
1550 {
1553 }
1558 varargs);
1559 }
1563 /* Range type. */
1568 /* FIXME: gdb checks os9k_stabs here. */
1569 /* Sun ACC builtin int type. */
1574 /* Sun ACC builtin float type. */
1579 /* Enumeration type. */
1585 /* Struct or union type. */
1591 /* Array type. */
1593 {
1596 }
1606 pp,
1608 stringp);
1614 }
1620 {
1623 }
1626 {
1629 }
1632 }
1634 /* Read a number by which a type is referred to in dbx data, or
1635 perhaps read a pair (FILENUM, TYPENUM) in parentheses. Just a
1636 single number N is equivalent to (0,N). Return the two numbers by
1637 storing them in the vector TYPENUMS. */
1639 static bfd_boolean
1643 {
1649 {
1652 }
1653 else
1654 {
1658 {
1661 }
1665 {
1668 }
1670 }
1673 }
1675 /* Parse a range type. */
1677 static debug_type
1679 PTR dhandle;
1684 {
1687 bfd_boolean self_subrange;
1688 debug_type index_type;
1697 /* First comes a type we are a subrange of.
1698 In C it is usually 0, 1 or the type being defined. */
1706 {
1712 }
1717 /* The remaining two operands are usually lower and upper bounds of
1718 the range. But in some special cases they mean something else. */
1722 {
1725 }
1731 {
1734 }
1738 {
1739 /* gcc will emit range stabs for long long types. Handle this
1740 as a special case. FIXME: This needs to be more general. */
1745 {
1753 }
1756 }
1759 {
1760 /* A type defined as a subrange of itself, with both bounds 0,
1761 is void. */
1765 /* A type defined as a subrange of itself, with n2 positive and
1766 n3 zero, is a complex type, and n2 is the number of bytes. */
1770 /* If n3 is zero and n2 is positive, this is a floating point
1771 type, and n2 is the number of bytes. */
1775 /* If the upper bound is -1, this is an unsigned int. */
1777 {
1778 /* When gcc is used with -gstabs, but not -gstabs+, it will emit
1779 long long int:t6=r1;0;-1;
1780 long long unsigned int:t7=r1;0;-1;
1781 We hack here to handle this reasonably. */
1783 {
1788 }
1789 /* FIXME: The size here really depends upon the target. */
1791 }
1793 /* A range of 0 to 127 is char. */
1797 /* FIXME: gdb checks for the language CHILL here. */
1800 {
1809 #ifdef BFD64
1812 #endif
1813 }
1819 {
1826 #ifdef BFD64
1829 #endif
1830 }
1831 }
1833 /* At this point I don't have the faintest idea how to deal with a
1834 self_subrange type; I'm going to assume that this is used as an
1835 idiom, and that all of them are special cases. So . . . */
1837 {
1840 }
1844 {
1845 /* Does this actually ever happen? Is that why we are worrying
1846 about dealing with it rather than just calling error_type? */
1849 }
1852 }
1854 /* Sun's ACC uses a somewhat saner method for specifying the builtin
1855 typedefs in every file (for int, long, etc):
1857 type = b <signed> <width>; <offset>; <nbits>
1858 signed = u or s. Possible c in addition to u or s (for char?).
1859 offset = offset from high order bit to start bit of type.
1860 width is # bytes in object of this type, nbits is # bits in type.
1862 The width/offset stuff appears to be for small objects stored in
1863 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
1864 FIXME. */
1866 static debug_type
1868 PTR dhandle;
1870 {
1872 bfd_boolean unsignedp;
1873 bfd_vma bits;
1878 {
1888 }
1891 /* For some odd reason, all forms of char put a c here. This is strange
1892 because no other type has this honor. We can safely ignore this because
1893 we actually determine 'char'acterness by the number of bits specified in
1894 the descriptor. */
1898 /* The first number appears to be the number of bytes occupied
1899 by this type, except that unsigned short is 4 instead of 2.
1900 Since this information is redundant with the third number,
1901 we will ignore it. */
1904 {
1907 }
1910 /* The second number is always 0, so ignore it too. */
1913 {
1916 }
1919 /* The third number is the number of bits for this type. */
1922 /* The type *should* end with a semicolon. If it are embedded
1923 in a larger type the semicolon may be the only way to know where
1924 the type ends. If this type is at the end of the stabstring we
1925 can deal with the omitted semicolon (but we don't have to like
1926 it). Don't bother to complain(), Sun's compiler omits the semicolon
1927 for "void". */
1935 }
1937 /* Parse a builtin floating type generated by the Sun compiler. */
1939 static debug_type
1941 PTR dhandle;
1943 {
1945 bfd_vma details;
1946 bfd_vma bytes;
1950 /* The first number has more details about the type, for example
1951 FN_COMPLEX. */
1954 {
1957 }
1959 /* The second number is the number of bytes occupied by this type */
1962 {
1965 }
1973 }
1975 /* Handle an enum type. */
1977 static debug_type
1979 PTR dhandle;
1981 {
1990 /* FIXME: gdb checks os9k_stabs here. */
1992 /* The aix4 compiler emits an extra field before the enum members;
1993 my guess is it's a type of some sort. Just ignore it. */
1995 {
1999 }
2001 /* Read the value-names and their values.
2002 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
2003 A semicolon or comma instead of a NAME means the end. */
2009 {
2012 bfd_signed_vma val;
2023 {
2026 }
2030 {
2036 }
2041 }
2050 }
2052 /* Read the description of a structure (or union type) and return an object
2053 describing the type.
2055 PP points to a character pointer that points to the next unconsumed token
2056 in the the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
2057 *PP will point to "4a:1,0,32;;". */
2059 static debug_type
2061 PTR dhandle;
2065 bfd_boolean structp;
2067 {
2069 bfd_vma size;
2072 bfd_boolean statics;
2074 debug_type vptrbase;
2075 bfd_boolean ownvptr;
2079 /* Get the size. */
2082 /* Get the other information. */
2099 }
2101 /* The stabs for C++ derived classes contain baseclass information which
2102 is marked by a '!' character after the total size. This function is
2103 called when we encounter the baseclass marker, and slurps up all the
2104 baseclass information.
2106 Immediately following the '!' marker is the number of base classes that
2107 the class is derived from, followed by information for each base class.
2108 For each base class, there are two visibility specifiers, a bit offset
2109 to the base class information within the derived class, a reference to
2110 the type for the base class, and a terminating semicolon.
2112 A typical example, with two base classes, would be "!2,020,19;0264,21;".
2113 ^^ ^ ^ ^ ^ ^ ^
2114 Baseclass information marker __________________|| | | | | | |
2115 Number of baseclasses __________________________| | | | | | |
2116 Visibility specifiers (2) ________________________| | | | | |
2117 Offset in bits from start of class _________________| | | | |
2118 Type number for base class ___________________________| | | |
2119 Visibility specifiers (2) _______________________________| | |
2120 Offset in bits from start of class ________________________| |
2121 Type number of base class ____________________________________|
2123 Return TRUE for success, FALSE for failure. */
2125 static bfd_boolean
2127 PTR dhandle;
2131 {
2141 {
2142 /* No base classes. */
2144 }
2150 {
2153 }
2159 {
2162 bfd_vma bitpos;
2163 debug_type type;
2166 {
2177 }
2181 {
2195 }
2198 /* The remaining value is the bit offset of the portion of the
2199 object corresponding to this baseclass. Always zero in the
2200 absence of multiple inheritance. */
2203 {
2206 }
2215 visibility);
2222 }
2229 }
2231 /* Read struct or class data fields. They have the form:
2233 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2235 At the end, we see a semicolon instead of a field.
2237 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2238 a static field.
2240 The optional VISIBILITY is one of:
2242 '/0' (VISIBILITY_PRIVATE)
2243 '/1' (VISIBILITY_PROTECTED)
2244 '/2' (VISIBILITY_PUBLIC)
2245 '/9' (VISIBILITY_IGNORE)
2247 or nothing, for C style fields with public visibility.
2249 Returns 1 for success, 0 for failure. */
2251 static bfd_boolean
2253 PTR dhandle;
2258 {
2274 {
2275 /* FIXME: gdb checks os9k_stabs here. */
2279 /* Add 1 to c to leave room for NULL pointer at end. */
2281 {
2285 }
2287 /* If it starts with CPLUS_MARKER it is a special abbreviation,
2288 unless the CPLUS_MARKER is followed by an underscore, in
2289 which case it is just the name of an anonymous type, which we
2290 should handle like any other type name. We accept either '$'
2291 or '.', because a field name can never contain one of these
2292 characters except as a CPLUS_MARKER. */
2295 {
2301 }
2303 /* Look for the ':' that separates the field name from the field
2304 values. Data members are delimited by a single ':', while member
2305 functions are delimited by a pair of ':'s. When we hit the member
2306 functions (if any), terminate scan loop and return. */
2310 {
2313 }
2319 staticsp))
2323 }
2330 }
2332 /* Special GNU C++ name. */
2334 static bfd_boolean
2336 PTR dhandle;
2340 {
2343 debug_type context;
2346 debug_type type;
2347 bfd_vma bitpos;
2354 {
2357 }
2363 /* At this point, *pp points to something like "22:23=*22...", where
2364 the type number before the ':' is the "context" and everything
2365 after is a regular type definition. Lookup the type, find it's
2366 name, and construct the field name. */
2374 {
2376 /* $vf -- a virtual function table pointer. */
2380 /* $vb -- a virtual bsomethingorother */
2383 {
2386 }
2393 }
2396 {
2399 }
2405 {
2408 }
2413 {
2416 }
2420 DEBUG_VISIBILITY_PRIVATE);
2425 }
2427 /* Parse a single field in a struct or union. */
2429 static bfd_boolean
2431 PTR dhandle;
2437 {
2441 debug_type type;
2442 bfd_vma bitpos;
2443 bfd_vma bitsize;
2447 /* FIXME: gdb checks ARM_DEMANGLING here. */
2455 else
2456 {
2459 {
2473 }
2475 }
2483 {
2486 /* This is a static class member. */
2490 {
2493 }
2500 visibility);
2504 }
2507 {
2510 }
2515 {
2518 }
2523 {
2526 }
2530 {
2531 /* This can happen in two cases: (1) at least for gcc 2.4.5 or
2532 so, it is a field which has been optimized out. The correct
2533 stab for this case is to use VISIBILITY_IGNORE, but that is a
2534 recent invention. (2) It is a 0-size array. For example
2535 union { int num; char str[0]; } foo. Printing "<no value>"
2536 for str in "p foo" is OK, since foo.str (and thus foo.str[3])
2537 will continue to work, and a 0-size array as a whole doesn't
2538 have any contents to print.
2540 I suspect this probably could also happen with gcc -gstabs
2541 (not -gstabs+) for static fields, and perhaps other C++
2542 extensions. Hopefully few people use -gstabs with gdb, since
2543 it is intended for dbx compatibility. */
2545 }
2547 /* FIXME: gdb does some stuff here to mark fields as unpacked. */
2552 }
2554 /* Read member function stabs info for C++ classes. The form of each member
2555 function data is:
2557 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2559 An example with two member functions is:
2561 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2563 For the case of overloaded operators, the format is op$::*.funcs, where
2564 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2565 name (such as `+=') and `.' marks the end of the operator name. */
2567 static bfd_boolean
2569 PTR dhandle;
2575 {
2590 {
2596 debug_type look_ahead_type;
2602 /* FIXME: Some systems use something other than '$' here. */
2604 {
2607 }
2608 else
2609 {
2610 /* This is a completely wierd case. In order to stuff in the
2611 names that might contain colons (the usual name delimiter),
2612 Mike Tiemann defined a different name format which is
2613 signalled if the identifier is "op$". In that case, the
2614 format is "op$::XXXX." where XXXX is the name. This is
2615 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2618 ;
2620 {
2623 }
2626 }
2635 do
2636 {
2637 debug_type type;
2638 bfd_boolean stub;
2642 bfd_vma voffset;
2643 debug_type context;
2645 bfd_boolean varargs;
2648 {
2649 /* g++ version 1 kludge */
2652 }
2653 else
2654 {
2660 {
2663 }
2664 }
2669 {
2672 }
2683 {
2693 }
2699 {
2701 /* Normal function. */
2705 /* const member function. */
2710 /* volatile member function. */
2715 /* const volatile member function. */
2723 /* File compiled with g++ version 1; no information. */
2728 }
2732 {
2734 /* virtual member function, followed by index. The sign
2735 bit is supposedly set to distinguish
2736 pointers-to-methods from virtual function indicies. */
2740 {
2743 }
2748 {
2749 /* Must be g++ version 1. */
2751 }
2752 else
2753 {
2754 /* Figure out from whence this virtual function
2755 came. It may belong to virtual function table of
2756 one of its baseclasses. */
2759 pp,
2762 {
2763 /* g++ version 1 overloaded methods. */
2765 }
2766 else
2767 {
2771 {
2774 }
2776 }
2777 }
2781 /* static member function. */
2801 }
2803 /* If the type is not a stub, then the argtypes string is
2804 the physical name of the function. Otherwise the
2805 argtypes string is the mangled form of the argument
2806 types, and the full type and the physical name must be
2807 extracted from them. */
2810 else
2811 {
2819 {
2822 }
2828 }
2831 {
2836 }
2843 else
2845 physname,
2846 type,
2847 visibility,
2848 constp,
2849 volatilep);
2854 }
2863 {
2867 }
2872 }
2880 }
2882 /* Parse a string representing argument types for a method. Stabs
2883 tries to save space by packing argument types into a mangled
2884 string. This string should give us enough information to extract
2885 both argument types and the physical name of the function, given
2886 the tag name. */
2888 static debug_type
2891 PTR dhandle;
2893 debug_type class_type;
2896 debug_type return_type;
2898 bfd_boolean constp;
2899 bfd_boolean volatilep;
2901 {
2902 bfd_boolean is_full_physname_constructor;
2903 bfd_boolean is_constructor;
2904 bfd_boolean is_destructor;
2906 bfd_boolean varargs;
2909 /* Constructors are sometimes handled specially. */
2917 is_constructor = (is_full_physname_constructor
2927 else
2928 {
2943 {
2944 /* Template methods are fully mangled. */
2948 }
2949 else
2954 + len
2961 {
2966 {
2969 }
2974 }
2975 else
2976 {
2980 else
2982 }
2991 }
2994 {
2998 FALSE);
2999 }
3006 varargs);
3007 }
3009 /* The tail end of stabs for C++ classes that contain a virtual function
3010 pointer contains a tilde, a %, and a type number.
3011 The type number refers to the base class (possibly this class itself) which
3012 contains the vtable pointer for the current class.
3014 This function is called when we have parsed all the method declarations,
3015 so we can look for the vptr base class info. */
3017 static bfd_boolean
3019 PTR dhandle;
3025 {
3035 /* If we are positioned at a ';', then skip it. */
3045 {
3046 /* Obsolete flags that used to indicate the presence of
3047 constructors and/or destructors. */
3049 }
3058 /* The next number is the type number of the base class (possibly
3059 our own class) which supplies the vtable for this class. */
3066 else
3067 {
3068 debug_type vtype;
3076 ;
3078 {
3081 }
3086 }
3089 }
3091 /* Read a definition of an array type. */
3093 static debug_type
3095 PTR dhandle;
3098 bfd_boolean stringp;
3099 {
3103 debug_type index_type;
3104 bfd_boolean adjustable;
3106 debug_type element_type;
3108 /* Format of an array type:
3109 "ar<index type>;lower;upper;<array_contents_type>".
3110 OS9000: "arlower,upper;<array_contents_type>".
3112 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3113 for these, produce a type like float[][]. */
3117 /* FIXME: gdb checks os9k_stabs here. */
3119 /* If the index type is type 0, we take it as int. */
3124 {
3127 {
3131 }
3133 }
3134 else
3135 {
3138 }
3141 {
3144 }
3150 {
3153 }
3157 {
3160 }
3164 {
3167 }
3171 {
3174 }
3183 {
3186 }
3190 }
3192 /* This struct holds information about files we have seen using
3193 N_BINCL. */
3195 struct bincl_file
3196 {
3197 /* The next N_BINCL file. */
3199 /* The next N_BINCL on the stack. */
3201 /* The file name. */
3203 /* The hash value. */
3204 bfd_vma hash;
3205 /* The file index. */
3207 /* The list of types defined in this file. */
3209 };
3211 /* Start a new N_BINCL file, pushing it onto the stack. */
3213 static void
3217 bfd_vma hash;
3218 {
3237 }
3239 /* Finish an N_BINCL file, at an N_EINCL, popping the name off the
3240 stack. */
3245 {
3258 }
3260 /* Handle an N_EXCL: get the types from the corresponding N_BINCL. */
3262 static bfd_boolean
3266 bfd_vma hash;
3267 {
3280 {
3284 }
3289 }
3291 /* Handle a variable definition. gcc emits variable definitions for a
3292 block before the N_LBRAC, so we must hold onto them until we see
3293 it. The SunPRO compiler emits variable definitions after the
3294 N_LBRAC, so we can call debug_record_variable immediately. */
3296 static bfd_boolean
3298 PTR dhandle;
3301 debug_type type;
3303 bfd_vma val;
3304 {
3323 }
3325 /* Emit pending variable definitions. This is called after we see the
3326 N_LBRAC that starts the block. */
3328 static bfd_boolean
3330 PTR dhandle;
3332 {
3337 {
3346 }
3351 }
3353 /* Find the slot for a type in the database. */
3359 {
3368 {
3371 }
3373 {
3376 }
3381 {
3383 {
3386 }
3389 }
3391 {
3394 }
3397 }
3399 /* Find a type given a type number. If the type has not been
3400 allocated yet, create an indirect type. */
3402 static debug_type
3404 PTR dhandle;
3407 {
3411 {
3412 /* A negative type number indicates an XCOFF builtin type. */
3414 }
3424 }
3426 /* Record that a given type number refers to a given type. */
3428 static bfd_boolean
3430 PTR dhandle ATTRIBUTE_UNUSED;
3433 debug_type type;
3434 {
3441 /* gdb appears to ignore type redefinitions, so we do as well. */
3446 }
3448 /* Return an XCOFF builtin type. */
3450 static debug_type
3452 PTR dhandle;
3455 {
3456 debug_type rettype;
3460 {
3463 }
3468 {
3470 /* The size of this and all the other types are fixed, defined
3471 by the debugging format. */
3515 /* IEEE single precision (32 bit). */
3520 /* IEEE double precision (64 bit). */
3525 /* This is an IEEE double on the RS/6000, and different machines
3526 with different sizes for "long double" should use different
3527 negative type numbers. See stabs.texinfo. */
3548 /* FIXME */
3553 /* FIXME */
3574 /* Complex type consisting of two IEEE single precision values. */
3579 /* Complex type consisting of two IEEE double precision values. */
3596 /* FIXME */
3618 }
3625 }
3627 /* Find or create a tagged type. */
3629 static debug_type
3631 PTR dhandle;
3636 {
3638 debug_type dtype;
3643 /* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same
3644 namespace. This is right for C, and I don't know how to handle
3645 other languages. FIXME. */
3648 {
3651 }
3653 /* We need to allocate an entry on the undefined tag list. */
3655 {
3658 {
3663 }
3664 }
3666 {
3676 }
3679 }
3680 \f
3681 /* In order to get the correct argument types for a stubbed method, we
3682 need to extract the argument types from a C++ mangled string.
3683 Since the argument types can refer back to the return type, this
3684 means that we must demangle the entire physical name. In gdb this
3685 is done by calling cplus_demangle and running the results back
3686 through the C++ expression parser. Since we have no expression
3687 parser, we must duplicate much of the work of cplus_demangle here.
3689 We assume that GNU style demangling is used, since this is only
3690 done for method stubs, and only g++ should output that form of
3691 debugging information. */
3693 /* This structure is used to hold a pointer to type information which
3694 demangling a string. */
3696 struct stab_demangle_typestring
3697 {
3698 /* The start of the type. This is not null terminated. */
3700 /* The length of the type. */
3702 };
3704 /* This structure is used to hold information while demangling a
3705 string. */
3707 struct stab_demangle_info
3708 {
3709 /* The debugging information handle. */
3710 PTR dhandle;
3711 /* The stab information handle. */
3713 /* The array of arguments we are building. */
3715 /* Whether the method takes a variable number of arguments. */
3716 bfd_boolean varargs;
3717 /* The array of types we have remembered. */
3719 /* The number of typestrings. */
3721 /* The number of typestring slots we have allocated. */
3723 };
3725 static void stab_bad_demangle
3727 static unsigned int stab_demangle_count
3729 static bfd_boolean stab_demangle_get_count
3731 static bfd_boolean stab_demangle_prefix
3733 static bfd_boolean stab_demangle_function_name
3735 static bfd_boolean stab_demangle_signature
3737 static bfd_boolean stab_demangle_qualified
3739 static bfd_boolean stab_demangle_template
3741 static bfd_boolean stab_demangle_class
3743 static bfd_boolean stab_demangle_args
3745 bfd_boolean *));
3746 static bfd_boolean stab_demangle_arg
3749 static bfd_boolean stab_demangle_type
3751 static bfd_boolean stab_demangle_fund_type
3753 static bfd_boolean stab_demangle_remember_type
3756 /* Warn about a bad demangling. */
3758 static void
3761 {
3763 }
3765 /* Get a count from a stab string. */
3767 static unsigned int
3770 {
3775 {
3779 }
3781 }
3783 /* Require a count in a string. The count may be multiple digits, in
3784 which case it must end in an underscore. */
3786 static bfd_boolean
3790 {
3797 {
3803 do
3804 {
3808 }
3811 {
3814 }
3815 }
3818 }
3820 /* This function demangles a physical name, returning a NULL
3821 terminated array of argument types. */
3825 PTR dhandle;
3830 {
3843 /* cplus_demangle checks for special GNU mangled forms, but we can't
3844 see any of them in mangled method argument types. */
3850 {
3853 }
3864 error_return:
3868 }
3870 /* Demangle the prefix of the mangled name. */
3872 static bfd_boolean
3877 {
3881 /* cplus_demangle checks for global constructors and destructors,
3882 but we can't see them in mangled argument types. */
3886 else
3887 {
3888 /* Look for `__'. */
3890 do
3895 {
3898 }
3902 /* We found `__'; move ahead to the last contiguous `__' pair. */
3906 }
3912 {
3913 /* This is a GNU style constructor name. */
3916 }
3920 {
3921 /* Look for the `__' that separates the prefix from the
3922 signature. */
3927 {
3930 }
3933 }
3935 {
3936 /* The name doesn't start with `__', but it does contain `__'. */
3938 }
3939 else
3940 {
3943 }
3944 /*NOTREACHED*/
3945 }
3947 /* Demangle a function name prefix. The scan argument points to the
3948 double underscore which separates the function name from the
3949 signature. */
3951 static bfd_boolean
3956 {
3959 /* The string from *pp to scan is the name of the function. We
3960 don't care about the name, since we just looking for argument
3961 types. However, for conversion operators, the name may include a
3962 type which we must remember in order to handle backreferences. */
3970 {
3973 /* This is a type conversion operator. */
3977 }
3982 {
3985 /* This is a type conversion operator. */
3989 }
3992 }
3994 /* Demangle the signature. This is where the argument types are
3995 found. */
3997 static bfd_boolean
4001 {
4013 {
4015 {
4026 /* Static member function. FIXME: Can this happen? */
4033 /* Const member function. */
4051 /* Function. I don't know if this actually happens with g++
4052 output. */
4061 /* Template. */
4072 /* At the outermost level, we cannot have a return type
4073 specified, so if we run into another '_' at this point we
4074 are dealing with a mangled name that is either bogus, or
4075 has been mangled by some algorithm we don't know how to
4076 deal with. So just reject the entire demangling. */
4081 /* Assume we have stumbled onto the first outermost function
4082 argument token, and start processing args. */
4087 }
4090 {
4094 }
4095 }
4098 {
4099 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
4100 bar__3fooi is 'foo::bar(int)'. We get here when we find the
4101 first case, and need to ensure that the '(void)' gets added
4102 to the current declp. */
4105 }
4108 }
4110 /* Demangle a qualified name, such as "Q25Outer5Inner" which is the
4111 mangled form of "Outer::Inner". */
4113 static bfd_boolean
4118 {
4122 debug_type context;
4127 {
4129 /* GNU mangled name with more than 9 classes. The count is
4130 preceded by an underscore (to distinguish it from the <= 9
4131 case) and followed by an underscore. */
4134 {
4137 }
4142 {
4145 }
4152 /* Skip an optional underscore after the count. */
4162 }
4166 /* Pick off the names. */
4168 {
4172 {
4180 {
4183 DEBUG_KIND_CLASS);
4187 }
4188 }
4189 else
4190 {
4195 {
4198 }
4201 {
4211 {
4214 /* Try to find the type by looking through the
4215 fields of context until we find a field with the
4216 same type. This ought to work for a class
4217 defined within a class, but it won't work for,
4218 e.g., an enum defined within a class. stabs does
4219 not give us enough information to figure out the
4220 latter case. */
4225 {
4226 debug_type ft;
4234 {
4237 }
4238 }
4241 }
4244 {
4245 /* We have to fall back on finding the type by name.
4246 If there are more types to come, then this must
4247 be a class. Otherwise, it could be anything. */
4250 {
4255 name);
4257 }
4260 {
4265 ? DEBUG_KIND_ILLEGAL
4269 }
4270 }
4271 }
4274 }
4275 }
4281 }
4283 /* Demangle a template. If PNAME is not NULL, this sets *PNAME to a
4284 string representation of the template. */
4286 static bfd_boolean
4291 {
4299 /* Skip the template name. */
4302 {
4305 }
4308 /* Get the size of the parameter list. */
4310 {
4313 }
4316 {
4318 {
4319 /* This is a type parameter. */
4323 }
4324 else
4325 {
4328 bfd_boolean done;
4338 /* This is a value parameter. */
4344 {
4346 {
4393 /* Assume it's a user defined integral type. */
4397 }
4398 }
4401 {
4406 }
4408 {
4415 {
4418 }
4419 }
4421 {
4426 {
4429 }
4430 }
4432 {
4438 {
4442 }
4444 {
4448 }
4449 }
4451 {
4455 {
4458 }
4460 }
4461 }
4462 }
4464 /* We can translate this to a string fairly easily by invoking the
4465 regular demangling routine. */
4467 {
4484 {
4489 }
4491 /* Eliminating all spaces, except those between > characters,
4492 makes it more likely that the demangled name will match the
4493 name which g++ used as the structure name. */
4502 }
4505 }
4507 /* Demangle a class name. */
4509 static bfd_boolean
4514 {
4522 {
4525 }
4533 }
4535 /* Demangle function arguments. If the pargs argument is not NULL, it
4536 is set to a NULL terminated array holding the arguments. */
4538 static bfd_boolean
4544 {
4552 {
4555 }
4559 {
4561 {
4570 else
4571 {
4573 {
4576 }
4577 }
4580 {
4583 }
4586 {
4589 }
4591 {
4597 }
4598 }
4599 else
4600 {
4603 }
4604 }
4610 {
4614 }
4617 }
4619 /* Demangle a single argument. */
4621 static bfd_boolean
4628 {
4630 debug_type type;
4639 {
4644 {
4648 }
4651 }
4654 }
4656 /* Demangle a type. If the ptype argument is not NULL, *ptype is set
4657 to the newly allocated type. */
4659 static bfd_boolean
4664 {
4670 {
4673 /* A pointer type. */
4682 /* A reference type. */
4691 /* An array. */
4692 {
4698 {
4700 {
4703 }
4707 }
4709 {
4712 }
4718 {
4719 debug_type int_type;
4726 }
4727 }
4731 /* A back reference to a remembered type. */
4732 {
4738 {
4741 }
4743 {
4746 }
4750 }
4754 /* A function. */
4755 {
4757 bfd_boolean varargs;
4769 {
4770 /* cplus_demangle will accept a function without a return
4771 type, but I don't know when that will happen, or what
4772 to do if it does. */
4775 }
4781 varargs);
4783 }
4788 {
4792 bfd_boolean varargs;
4804 {
4807 {
4810 }
4815 {
4819 DEBUG_KIND_CLASS);
4822 }
4823 }
4825 {
4831 }
4832 else
4833 {
4836 }
4839 {
4841 {
4844 }
4846 {
4849 }
4851 {
4854 }
4864 }
4867 {
4870 }
4877 {
4881 else
4882 {
4883 /* FIXME: We have no way to record constp or
4884 volatilep. */
4887 }
4888 }
4889 }
4907 {
4913 }
4920 }
4923 }
4925 /* Demangle a fundamental type. If the ptype argument is not NULL,
4926 *ptype is set to the newly allocated type. */
4928 static bfd_boolean
4933 {
4936 bfd_boolean done;
4947 {
4949 {
4973 }
4974 }
4977 {
4980 /* cplus_demangle permits this, but I don't know what it means. */
4986 {
4990 }
4996 {
4998 (unsignedp
5003 }
5009 {
5011 (unsignedp
5016 }
5022 {
5024 (unsignedp
5029 }
5035 {
5037 (unsignedp
5042 }
5048 {
5052 }
5058 {
5060 (unsignedp
5062 : (signedp
5067 }
5073 {
5077 }
5083 {
5087 }
5093 {
5097 }
5103 {
5107 }
5114 {
5117 }
5118 /* Fall through. */
5121 {
5127 {
5134 {
5135 /* FIXME: It is probably incorrect to assume that
5136 undefined types are tagged types. */
5139 DEBUG_KIND_ILLEGAL);
5142 }
5143 }
5144 }
5148 {
5155 {
5158 DEBUG_KIND_CLASS);
5162 }
5163 }
5169 }
5172 {
5177 }
5180 }
5182 /* Remember a type string in a demangled string. */
5184 static bfd_boolean
5189 {
5191 {
5197 }
5204 }