| blob | 1ff4f6f60d220903a26be3495a4bcf53b62459bf |
1 /* stabs.c -- Parse stabs debugging information
2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002
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>
39 /* Meaningless definition needs by aout64.h. FIXME. */
40 #define BYTES_IN_WORD 4
45 /* The number of predefined XCOFF types. */
47 #define XCOFF_TYPE_COUNT 34
49 /* This structure is used as a handle so that the stab parsing doesn't
50 need to use any static variables. */
52 struct stab_handle
53 {
54 /* The BFD. */
56 /* TRUE if this is stabs in sections. */
57 bfd_boolean sections;
58 /* The symbol table. */
60 /* The number of symbols. */
62 /* The accumulated file name string. */
64 /* The value of the last N_SO symbol. */
65 bfd_vma so_value;
66 /* The value of the start of the file, so that we can handle file
67 relative N_LBRAC and N_RBRAC symbols. */
68 bfd_vma file_start_offset;
69 /* The offset of the start of the function, so that we can handle
70 function relative N_LBRAC and N_RBRAC symbols. */
71 bfd_vma function_start_offset;
72 /* The version number of gcc which compiled the current compilation
73 unit, 0 if not compiled by gcc. */
75 /* Whether an N_OPT symbol was seen that was not generated by gcc,
76 so that we can detect the SunPRO compiler. */
77 bfd_boolean n_opt_found;
78 /* The main file name. */
80 /* A stack of unfinished N_BINCL files. */
82 /* A list of finished N_BINCL files. */
84 /* Whether we are inside a function or not. */
85 bfd_boolean within_function;
86 /* The address of the end of the function, used if we have seen an
87 N_FUN symbol while in a function. This is -1 if we have not seen
88 an N_FUN (the normal case). */
89 bfd_vma function_end;
90 /* The depth of block nesting. */
92 /* List of pending variable definitions. */
94 /* Number of files for which we have types. */
96 /* Lists of types per file. */
98 /* Predefined XCOFF types. */
100 /* Undefined tags. */
102 /* Set by parse_stab_type if it sees a structure defined as a cross
103 reference to itself. Reset by parse_stab_type otherwise. */
104 bfd_boolean self_crossref;
105 };
107 /* A list of these structures is used to hold pending variable
108 definitions seen before the N_LBRAC of a block. */
110 struct stab_pending_var
111 {
112 /* Next pending variable definition. */
114 /* Name. */
116 /* Type. */
117 debug_type type;
118 /* Kind. */
120 /* Value. */
121 bfd_vma val;
122 };
124 /* A list of these structures is used to hold the types for a single
125 file. */
127 struct stab_types
128 {
129 /* Next set of slots for this file. */
131 /* Types indexed by type number. */
132 #define STAB_TYPES_SLOTS (16)
134 };
136 /* We keep a list of undefined tags that we encounter, so that we can
137 fill them in if the tag is later defined. */
139 struct stab_tag
140 {
141 /* Next undefined tag. */
143 /* Tag name. */
145 /* Type kind. */
147 /* Slot to hold real type when we discover it. If we don't, we fill
148 in an undefined tag type. */
149 debug_type slot;
150 /* Indirect type we have created to point at slot. */
151 debug_type type;
152 };
156 static bfd_vma parse_number
158 static void bad_stab
160 static void warn_stab
162 static bfd_boolean parse_stab_string
164 static debug_type parse_stab_type
166 debug_type **));
167 static bfd_boolean parse_stab_type_number
169 static debug_type parse_stab_range_type
172 static debug_type parse_stab_sun_builtin_type
174 static debug_type parse_stab_sun_floating_type
176 static debug_type parse_stab_enum_type
178 static debug_type parse_stab_struct_type
181 static bfd_boolean parse_stab_baseclasses
183 static bfd_boolean parse_stab_struct_fields
185 bfd_boolean *));
186 static bfd_boolean parse_stab_cpp_abbrev
188 static bfd_boolean parse_stab_one_struct_field
191 static bfd_boolean parse_stab_members
194 static debug_type parse_stab_argtypes
197 static bfd_boolean parse_stab_tilde_field
200 static debug_type parse_stab_array_type
202 static void push_bincl
206 static bfd_boolean find_excl
208 static bfd_boolean stab_record_variable
211 static bfd_boolean stab_emit_pending_vars
215 static debug_type stab_find_type
217 static bfd_boolean stab_record_type
219 static debug_type stab_xcoff_builtin_type
221 static debug_type stab_find_tagged_type
227 /* Save a string in memory. */
233 {
240 }
242 /* Read a number from a string. */
244 static bfd_vma
248 {
260 {
261 /* If bfd_vma is larger than unsigned long, and the number is
262 meant to be negative, we have to make sure that we sign
263 extend properly. */
267 }
269 /* Note that even though strtoul overflowed, it should have set *pp
270 to the end of the number, which is where we want it. */
273 {
275 bfd_boolean neg;
278 bfd_boolean overflow;
279 bfd_vma v;
281 /* Our own version of strtoul, for a bfd_vma. */
289 {
292 }
296 {
298 {
301 }
302 else
303 {
306 }
307 }
315 {
325 else
332 {
335 }
336 }
339 {
343 }
344 }
346 /* If we get here, the number is too large to represent in a
347 bfd_vma. */
351 else
355 }
357 /* Give an error for a bad stab string. */
359 static void
362 {
364 }
366 /* Warn about something in a stab string. */
368 static void
372 {
374 }
376 /* Create a handle to parse stabs symbols with. */
378 PTR
380 PTR dhandle ATTRIBUTE_UNUSED;
382 bfd_boolean sections;
385 {
399 }
401 /* When we have processed all the stabs information, we need to go
402 through and fill in all the undefined tags. */
404 bfd_boolean
406 PTR dhandle;
407 PTR handle;
408 {
413 {
419 }
422 {
431 }
434 }
436 /* Handle a single stabs symbol. */
438 bfd_boolean
440 PTR dhandle;
441 PTR handle;
444 bfd_vma value;
446 {
449 /* gcc will emit two N_SO strings per compilation unit, one for the
450 directory name and one for the file name. We just collect N_SO
451 strings as we see them, and start the new compilation unit when
452 we see a non N_SO symbol. */
455 {
463 /* Generally, for stabs in the symbol table, the N_LBRAC and
464 N_RBRAC symbols are relative to the N_SO symbol value. */
468 /* We need to reset the mapping from type numbers to types. We
469 can't free the old mapping, because of the use of
470 debug_make_indirect_type. */
478 /* Now process whatever type we just got. */
479 }
482 {
488 /* Ignore extra outermost context from SunPRO cc and acc. */
493 {
496 }
498 /* Start an inner lexical block. */
500 (value
505 /* Emit any pending variable definitions. */
513 /* Ignore extra outermost context from SunPRO cc and acc. */
517 /* We shouldn't have any pending variable definitions here, but,
518 if we do, we probably need to emit them before closing the
519 block. */
523 /* End an inner lexical block. */
525 (value
532 {
535 }
539 /* This always ends a function. */
541 {
542 bfd_vma endval;
554 }
556 /* An empty string is emitted by gcc at the end of a compilation
557 unit. */
561 /* Just accumulate strings until we see a non N_SO symbol. If
562 the string starts with a directory separator or some other
563 form of absolute path specification, we discard the previously
564 accumulated strings. */
567 else
568 {
575 else
579 }
586 /* Start an include file. */
592 /* Start an include file which may be replaced. */
599 /* End an N_BINCL include. */
605 /* This is a duplicate of a header file named by N_BINCL which
606 was eliminated by the linker. */
629 {
631 {
632 /* This always marks the end of a function; we don't
633 need to worry about info->function_end. */
641 }
643 }
645 /* A const static symbol in the .text section will have an N_FUN
646 entry. We need to use these to mark the end of the function,
647 in case we are looking at gcc output before it was changed to
648 always emit an empty N_FUN. We can't call debug_end_function
649 here, because it might be a local static symbol. */
655 /* Fall through. */
656 /* FIXME: gdb checks the string for N_STSYM, N_LCSYM or N_ROSYM
657 symbols, and if it does not start with :S, gdb relocates the
658 value to the start of the section. gcc always seems to use
659 :S, so we don't worry about this. */
660 /* Fall through. */
662 {
668 {
670 {
671 bfd_vma endval;
681 }
682 /* For stabs in sections, line numbers and block addresses
683 are offsets from the start of the function. */
687 }
691 }
699 else
708 }
711 }
713 /* Parse the stabs string. */
715 static bfd_boolean
717 PTR dhandle;
721 bfd_vma value;
723 {
727 debug_type dtype;
728 bfd_boolean synonym;
729 bfd_boolean self_crossref;
738 {
742 {
745 }
746 }
748 /* GCC 2.x puts the line number in desc. SunOS apparently puts in
749 the number of bytes occupied by a type or object, which we
750 ignore. */
753 else
756 /* FIXME: Sometimes the special C++ names start with '.'. */
759 {
761 {
766 /* Was: name = "vptr"; */
772 /* This was an anonymous type that was never fixed up. */
775 /* SunPRO (3.0 at least) static variable encoding. */
780 }
781 }
784 {
787 else
789 }
794 else
798 {
800 /* c is a special case, not followed by a type-number.
801 SYMBOL:c=iVALUE for an integer constant symbol.
802 SYMBOL:c=rVALUE for a floating constant symbol.
803 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
804 e.g. "b:c=e6,0" for "const b = blob1"
805 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
807 {
810 }
813 {
815 /* Floating point constant. */
820 /* Integer constant. */
821 /* Defining integer constants this way is kind of silly,
822 since 'e' constants allows the compiler to give not only
823 the value, but the type as well. C has at least int,
824 long, unsigned int, and long long as constant types;
825 other languages probably should have at least unsigned as
826 well as signed constants. */
831 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
832 can be represented as integral.
833 e.g. "b:c=e6,0" for "const b = blob1"
834 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
840 {
843 }
850 }
855 /* The name of a caught exception. */
866 /* A function definition. */
874 /* Sun acc puts declared types of arguments here. We don't care
875 about their actual types (FIXME -- we should remember the whole
876 function prototype), but the list may define some new types
877 that we have to remember, so we must scan it now. */
879 {
885 }
890 {
895 /* A global symbol. The value must be extracted from the
896 symbol table. */
903 {
911 }
915 value))
917 }
920 /* This case is faked by a conditional above, when there is no
921 code letter in the dbx data. Dbx data never actually
922 contains 'l'. */
930 value))
935 /* A function parameter. */
939 else
940 {
941 /* pF is a two-letter code that means a function parameter in
942 Fortran. The type-number specifies the type of the return
943 value. Translate it into a pointer-to-function type. */
948 {
949 debug_type ftype;
954 }
955 }
959 value))
962 /* FIXME: At this point gdb considers rearranging the parameter
963 address on a big endian machine if it is smaller than an int.
964 We have no way to do that, since we don't really know much
965 about the target. */
971 {
972 /* Prototype of a function referenced by this file. */
974 {
980 }
982 }
983 /* Fall through. */
985 /* Parameter which is in a register. */
991 value))
996 /* Register variable (either global or local). */
1002 value))
1005 /* FIXME: At this point gdb checks to combine pairs of 'p' and
1006 'r' stabs into a single 'P' stab. */
1011 /* Static symbol at top level of file */
1017 value))
1022 /* A typedef. */
1027 {
1028 /* A nameless type. Nothing to do. */
1030 }
1042 /* Struct, union, or enum tag. For GNU C++, this can be be followed
1043 by 't' which means we are typedef'ing it as well. */
1045 {
1047 /* FIXME: gdb sets synonym to TRUE if the current language
1048 is C++. */
1049 }
1050 else
1051 {
1054 }
1062 /* INFO->SELF_CROSSREF is set by parse_stab_type if this type is
1063 a cross reference to itself. These are generated by some
1064 versions of g++. */
1073 /* See if we have a cross reference to this tag which we can now
1074 fill in. Avoid filling in a cross reference to ourselves,
1075 because that would lead to circular debugging information. */
1077 {
1081 {
1084 {
1088 }
1089 }
1090 }
1093 {
1100 }
1105 /* Static symbol of local scope */
1110 /* FIXME: gdb checks os9k_stabs here. */
1117 /* Reference parameter. */
1123 value))
1128 /* Reference parameter which is in a register. */
1134 value))
1139 /* This is used by Sun FORTRAN for "function result value".
1140 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1141 that Pascal uses it too, but when I tried it Pascal used
1142 "x:3" (local symbol) instead. */
1148 value))
1155 }
1157 /* FIXME: gdb converts structure values to structure pointers in a
1158 couple of cases, depending upon the target. */
1161 }
1163 /* Parse a stabs type. The typename argument is non-NULL if this is a
1164 typedef or a tag definition. The pp argument points to the stab
1165 string, and is updated. The slotp argument points to a place to
1166 store the slot used if the type is being defined. */
1168 static debug_type
1170 PTR dhandle;
1175 {
1179 bfd_boolean stringp;
1181 debug_type dtype;
1193 /* Read type number if present. The type number may be omitted.
1194 for instance in a two-dimensional array declared with type
1195 "ar1;1;10;ar1;1;10;4". */
1197 {
1198 /* 'typenums=' not present, type is anonymous. Read and return
1199 the definition, but don't put it in the type vector. */
1201 }
1202 else
1203 {
1208 {
1209 /* Type is not being defined here. Either it already
1210 exists, or this is a forward reference to it. */
1212 }
1214 /* Only set the slot if the type is being defined. This means
1215 that the mapping from type numbers to types will only record
1216 the name of the typedef which defines a type. If we don't do
1217 this, then something like
1218 typedef int foo;
1219 int i;
1220 will record that i is of type foo. Unfortunately, stabs
1221 information is ambiguous about variable types. For this code,
1222 typedef int foo;
1223 int i;
1224 foo j;
1225 the stabs information records both i and j as having the same
1226 type. This could be fixed by patching the compiler. */
1230 /* Type is being defined here. */
1231 /* Skip the '='. */
1235 {
1240 {
1241 /* Member type. */
1243 }
1245 /* Type attributes. */
1249 {
1251 {
1254 }
1255 }
1259 {
1272 /* Ignore unrecognized type attributes, so future
1273 compilers can invent new ones. */
1275 }
1276 }
1277 }
1283 {
1285 {
1289 /* A cross reference to another type. */
1292 {
1303 /* Complain and keep going, so compilers can invent new
1304 cross-reference types. */
1308 }
1314 {
1317 }
1319 {
1323 {
1330 }
1333 {
1336 }
1337 }
1339 /* Some versions of g++ can emit stabs like
1340 fleep:T20=xsfleep:
1341 which define structures in terms of themselves. We need to
1342 tell the caller to avoid building a circular structure. */
1351 }
1366 {
1370 /* This type is defined as another type. */
1375 /* Peek ahead at the number to detect void. */
1380 {
1381 /* This type is being defined as itself, which means that
1382 it is void. */
1384 }
1385 else
1386 {
1389 /* Go back to the number and have parse_stab_type get it.
1390 This means that we can deal with something like
1391 t(1,2)=(3,4)=... which the Lucid compiler uses. */
1396 }
1399 {
1402 }
1405 }
1411 pp,
1416 /* Reference to another type. */
1417 dtype = (debug_make_reference_type
1424 /* Function returning another type. */
1425 /* FIXME: gdb checks os9k_stabs here. */
1426 dtype = (debug_make_function_type
1434 /* Const qualifier on some type (Sun). */
1435 /* FIXME: gdb accepts 'c' here if os9k_stabs. */
1439 pp,
1444 /* Volatile qual on some type (Sun). */
1445 /* FIXME: gdb accepts 'i' here if os9k_stabs. */
1446 dtype = (debug_make_volatile_type
1453 /* Offset (class & variable) type. This is used for a pointer
1454 relative to an object. */
1455 {
1456 debug_type domain;
1457 debug_type memtype;
1459 /* Member type. */
1467 {
1470 }
1479 }
1483 /* Method (class & fn) type. */
1485 {
1486 debug_type return_type;
1494 {
1497 }
1500 DEBUG_TYPE_NULL,
1502 }
1503 else
1504 {
1505 debug_type domain;
1506 debug_type return_type;
1510 bfd_boolean varargs;
1518 {
1521 }
1533 {
1535 {
1538 }
1542 {
1546 }
1553 }
1556 /* If the last type is not void, then this function takes a
1557 variable number of arguments. Otherwise, we must strip
1558 the void type. */
1562 else
1563 {
1566 }
1571 varargs);
1572 }
1576 /* Range type. */
1581 /* FIXME: gdb checks os9k_stabs here. */
1582 /* Sun ACC builtin int type. */
1587 /* Sun ACC builtin float type. */
1592 /* Enumeration type. */
1598 /* Struct or union type. */
1604 /* Array type. */
1606 {
1609 }
1619 pp,
1621 stringp);
1627 }
1633 {
1636 }
1639 {
1642 }
1645 }
1647 /* Read a number by which a type is referred to in dbx data, or
1648 perhaps read a pair (FILENUM, TYPENUM) in parentheses. Just a
1649 single number N is equivalent to (0,N). Return the two numbers by
1650 storing them in the vector TYPENUMS. */
1652 static bfd_boolean
1656 {
1662 {
1665 }
1666 else
1667 {
1671 {
1674 }
1678 {
1681 }
1683 }
1686 }
1688 /* Parse a range type. */
1690 static debug_type
1692 PTR dhandle;
1697 {
1700 bfd_boolean self_subrange;
1701 debug_type index_type;
1710 /* First comes a type we are a subrange of.
1711 In C it is usually 0, 1 or the type being defined. */
1719 {
1725 }
1730 /* The remaining two operands are usually lower and upper bounds of
1731 the range. But in some special cases they mean something else. */
1735 {
1738 }
1744 {
1747 }
1751 {
1752 /* gcc will emit range stabs for long long types. Handle this
1753 as a special case. FIXME: This needs to be more general. */
1758 {
1766 }
1769 }
1772 {
1773 /* A type defined as a subrange of itself, with both bounds 0,
1774 is void. */
1778 /* A type defined as a subrange of itself, with n2 positive and
1779 n3 zero, is a complex type, and n2 is the number of bytes. */
1783 /* If n3 is zero and n2 is positive, this is a floating point
1784 type, and n2 is the number of bytes. */
1788 /* If the upper bound is -1, this is an unsigned int. */
1790 {
1791 /* When gcc is used with -gstabs, but not -gstabs+, it will emit
1792 long long int:t6=r1;0;-1;
1793 long long unsigned int:t7=r1;0;-1;
1794 We hack here to handle this reasonably. */
1796 {
1801 }
1802 /* FIXME: The size here really depends upon the target. */
1804 }
1806 /* A range of 0 to 127 is char. */
1810 /* FIXME: gdb checks for the language CHILL here. */
1813 {
1822 #ifdef BFD64
1825 #endif
1826 }
1832 {
1839 #ifdef BFD64
1842 #endif
1843 }
1844 }
1846 /* At this point I don't have the faintest idea how to deal with a
1847 self_subrange type; I'm going to assume that this is used as an
1848 idiom, and that all of them are special cases. So . . . */
1850 {
1853 }
1857 {
1858 /* Does this actually ever happen? Is that why we are worrying
1859 about dealing with it rather than just calling error_type? */
1862 }
1865 }
1867 /* Sun's ACC uses a somewhat saner method for specifying the builtin
1868 typedefs in every file (for int, long, etc):
1870 type = b <signed> <width>; <offset>; <nbits>
1871 signed = u or s. Possible c in addition to u or s (for char?).
1872 offset = offset from high order bit to start bit of type.
1873 width is # bytes in object of this type, nbits is # bits in type.
1875 The width/offset stuff appears to be for small objects stored in
1876 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
1877 FIXME. */
1879 static debug_type
1881 PTR dhandle;
1883 {
1885 bfd_boolean unsignedp;
1886 bfd_vma bits;
1891 {
1901 }
1904 /* For some odd reason, all forms of char put a c here. This is strange
1905 because no other type has this honor. We can safely ignore this because
1906 we actually determine 'char'acterness by the number of bits specified in
1907 the descriptor. */
1911 /* The first number appears to be the number of bytes occupied
1912 by this type, except that unsigned short is 4 instead of 2.
1913 Since this information is redundant with the third number,
1914 we will ignore it. */
1917 {
1920 }
1923 /* The second number is always 0, so ignore it too. */
1926 {
1929 }
1932 /* The third number is the number of bits for this type. */
1935 /* The type *should* end with a semicolon. If it are embedded
1936 in a larger type the semicolon may be the only way to know where
1937 the type ends. If this type is at the end of the stabstring we
1938 can deal with the omitted semicolon (but we don't have to like
1939 it). Don't bother to complain(), Sun's compiler omits the semicolon
1940 for "void". */
1948 }
1950 /* Parse a builtin floating type generated by the Sun compiler. */
1952 static debug_type
1954 PTR dhandle;
1956 {
1958 bfd_vma details;
1959 bfd_vma bytes;
1963 /* The first number has more details about the type, for example
1964 FN_COMPLEX. */
1967 {
1970 }
1972 /* The second number is the number of bytes occupied by this type */
1975 {
1978 }
1986 }
1988 /* Handle an enum type. */
1990 static debug_type
1992 PTR dhandle;
1994 {
2003 /* FIXME: gdb checks os9k_stabs here. */
2005 /* The aix4 compiler emits an extra field before the enum members;
2006 my guess is it's a type of some sort. Just ignore it. */
2008 {
2012 }
2014 /* Read the value-names and their values.
2015 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
2016 A semicolon or comma instead of a NAME means the end. */
2022 {
2025 bfd_signed_vma val;
2036 {
2039 }
2043 {
2049 }
2054 }
2063 }
2065 /* Read the description of a structure (or union type) and return an object
2066 describing the type.
2068 PP points to a character pointer that points to the next unconsumed token
2069 in the the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
2070 *PP will point to "4a:1,0,32;;". */
2072 static debug_type
2074 PTR dhandle;
2078 bfd_boolean structp;
2080 {
2082 bfd_vma size;
2085 bfd_boolean statics;
2087 debug_type vptrbase;
2088 bfd_boolean ownvptr;
2092 /* Get the size. */
2095 /* Get the other information. */
2112 }
2114 /* The stabs for C++ derived classes contain baseclass information which
2115 is marked by a '!' character after the total size. This function is
2116 called when we encounter the baseclass marker, and slurps up all the
2117 baseclass information.
2119 Immediately following the '!' marker is the number of base classes that
2120 the class is derived from, followed by information for each base class.
2121 For each base class, there are two visibility specifiers, a bit offset
2122 to the base class information within the derived class, a reference to
2123 the type for the base class, and a terminating semicolon.
2125 A typical example, with two base classes, would be "!2,020,19;0264,21;".
2126 ^^ ^ ^ ^ ^ ^ ^
2127 Baseclass information marker __________________|| | | | | | |
2128 Number of baseclasses __________________________| | | | | | |
2129 Visibility specifiers (2) ________________________| | | | | |
2130 Offset in bits from start of class _________________| | | | |
2131 Type number for base class ___________________________| | | |
2132 Visibility specifiers (2) _______________________________| | |
2133 Offset in bits from start of class ________________________| |
2134 Type number of base class ____________________________________|
2136 Return TRUE for success, FALSE for failure. */
2138 static bfd_boolean
2140 PTR dhandle;
2144 {
2154 {
2155 /* No base classes. */
2157 }
2163 {
2166 }
2172 {
2175 bfd_vma bitpos;
2176 debug_type type;
2179 {
2190 }
2194 {
2208 }
2211 /* The remaining value is the bit offset of the portion of the
2212 object corresponding to this baseclass. Always zero in the
2213 absence of multiple inheritance. */
2216 {
2219 }
2228 visibility);
2235 }
2242 }
2244 /* Read struct or class data fields. They have the form:
2246 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2248 At the end, we see a semicolon instead of a field.
2250 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2251 a static field.
2253 The optional VISIBILITY is one of:
2255 '/0' (VISIBILITY_PRIVATE)
2256 '/1' (VISIBILITY_PROTECTED)
2257 '/2' (VISIBILITY_PUBLIC)
2258 '/9' (VISIBILITY_IGNORE)
2260 or nothing, for C style fields with public visibility.
2262 Returns 1 for success, 0 for failure. */
2264 static bfd_boolean
2266 PTR dhandle;
2271 {
2287 {
2288 /* FIXME: gdb checks os9k_stabs here. */
2292 /* Add 1 to c to leave room for NULL pointer at end. */
2294 {
2298 }
2300 /* If it starts with CPLUS_MARKER it is a special abbreviation,
2301 unless the CPLUS_MARKER is followed by an underscore, in
2302 which case it is just the name of an anonymous type, which we
2303 should handle like any other type name. We accept either '$'
2304 or '.', because a field name can never contain one of these
2305 characters except as a CPLUS_MARKER. */
2308 {
2314 }
2316 /* Look for the ':' that separates the field name from the field
2317 values. Data members are delimited by a single ':', while member
2318 functions are delimited by a pair of ':'s. When we hit the member
2319 functions (if any), terminate scan loop and return. */
2323 {
2326 }
2332 staticsp))
2336 }
2343 }
2345 /* Special GNU C++ name. */
2347 static bfd_boolean
2349 PTR dhandle;
2353 {
2356 debug_type context;
2359 debug_type type;
2360 bfd_vma bitpos;
2367 {
2370 }
2376 /* At this point, *pp points to something like "22:23=*22...", where
2377 the type number before the ':' is the "context" and everything
2378 after is a regular type definition. Lookup the type, find it's
2379 name, and construct the field name. */
2387 {
2389 /* $vf -- a virtual function table pointer. */
2393 /* $vb -- a virtual bsomethingorother */
2396 {
2399 }
2406 }
2409 {
2412 }
2418 {
2421 }
2426 {
2429 }
2433 DEBUG_VISIBILITY_PRIVATE);
2438 }
2440 /* Parse a single field in a struct or union. */
2442 static bfd_boolean
2444 PTR dhandle;
2450 {
2454 debug_type type;
2455 bfd_vma bitpos;
2456 bfd_vma bitsize;
2460 /* FIXME: gdb checks ARM_DEMANGLING here. */
2468 else
2469 {
2472 {
2486 }
2488 }
2496 {
2499 /* This is a static class member. */
2503 {
2506 }
2513 visibility);
2517 }
2520 {
2523 }
2528 {
2531 }
2536 {
2539 }
2543 {
2544 /* This can happen in two cases: (1) at least for gcc 2.4.5 or
2545 so, it is a field which has been optimized out. The correct
2546 stab for this case is to use VISIBILITY_IGNORE, but that is a
2547 recent invention. (2) It is a 0-size array. For example
2548 union { int num; char str[0]; } foo. Printing "<no value>"
2549 for str in "p foo" is OK, since foo.str (and thus foo.str[3])
2550 will continue to work, and a 0-size array as a whole doesn't
2551 have any contents to print.
2553 I suspect this probably could also happen with gcc -gstabs
2554 (not -gstabs+) for static fields, and perhaps other C++
2555 extensions. Hopefully few people use -gstabs with gdb, since
2556 it is intended for dbx compatibility. */
2558 }
2560 /* FIXME: gdb does some stuff here to mark fields as unpacked. */
2565 }
2567 /* Read member function stabs info for C++ classes. The form of each member
2568 function data is:
2570 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2572 An example with two member functions is:
2574 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2576 For the case of overloaded operators, the format is op$::*.funcs, where
2577 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2578 name (such as `+=') and `.' marks the end of the operator name. */
2580 static bfd_boolean
2582 PTR dhandle;
2588 {
2603 {
2609 debug_type look_ahead_type;
2615 /* FIXME: Some systems use something other than '$' here. */
2617 {
2620 }
2621 else
2622 {
2623 /* This is a completely wierd case. In order to stuff in the
2624 names that might contain colons (the usual name delimiter),
2625 Mike Tiemann defined a different name format which is
2626 signalled if the identifier is "op$". In that case, the
2627 format is "op$::XXXX." where XXXX is the name. This is
2628 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2631 ;
2633 {
2636 }
2639 }
2648 do
2649 {
2650 debug_type type;
2651 bfd_boolean stub;
2655 bfd_vma voffset;
2656 debug_type context;
2658 bfd_boolean varargs;
2661 {
2662 /* g++ version 1 kludge */
2665 }
2666 else
2667 {
2673 {
2676 }
2677 }
2682 {
2685 }
2696 {
2706 }
2712 {
2714 /* Normal function. */
2718 /* const member function. */
2723 /* volatile member function. */
2728 /* const volatile member function. */
2736 /* File compiled with g++ version 1; no information. */
2741 }
2745 {
2747 /* virtual member function, followed by index. The sign
2748 bit is supposedly set to distinguish
2749 pointers-to-methods from virtual function indicies. */
2753 {
2756 }
2761 {
2762 /* Must be g++ version 1. */
2764 }
2765 else
2766 {
2767 /* Figure out from whence this virtual function
2768 came. It may belong to virtual function table of
2769 one of its baseclasses. */
2772 pp,
2775 {
2776 /* g++ version 1 overloaded methods. */
2778 }
2779 else
2780 {
2784 {
2787 }
2789 }
2790 }
2794 /* static member function. */
2814 }
2816 /* If the type is not a stub, then the argtypes string is
2817 the physical name of the function. Otherwise the
2818 argtypes string is the mangled form of the argument
2819 types, and the full type and the physical name must be
2820 extracted from them. */
2823 else
2824 {
2832 {
2835 }
2841 }
2844 {
2849 }
2856 else
2858 physname,
2859 type,
2860 visibility,
2861 constp,
2862 volatilep);
2867 }
2876 {
2880 }
2885 }
2893 }
2895 /* Parse a string representing argument types for a method. Stabs
2896 tries to save space by packing argument types into a mangled
2897 string. This string should give us enough information to extract
2898 both argument types and the physical name of the function, given
2899 the tag name. */
2901 static debug_type
2904 PTR dhandle;
2906 debug_type class_type;
2909 debug_type return_type;
2911 bfd_boolean constp;
2912 bfd_boolean volatilep;
2914 {
2915 bfd_boolean is_full_physname_constructor;
2916 bfd_boolean is_constructor;
2917 bfd_boolean is_destructor;
2919 bfd_boolean varargs;
2922 /* Constructors are sometimes handled specially. */
2930 is_constructor = (is_full_physname_constructor
2940 else
2941 {
2956 {
2957 /* Template methods are fully mangled. */
2961 }
2962 else
2967 + len
2974 {
2979 {
2982 }
2987 }
2988 else
2989 {
2993 else
2995 }
3004 }
3007 {
3011 FALSE);
3012 }
3019 varargs);
3020 }
3022 /* The tail end of stabs for C++ classes that contain a virtual function
3023 pointer contains a tilde, a %, and a type number.
3024 The type number refers to the base class (possibly this class itself) which
3025 contains the vtable pointer for the current class.
3027 This function is called when we have parsed all the method declarations,
3028 so we can look for the vptr base class info. */
3030 static bfd_boolean
3032 PTR dhandle;
3038 {
3048 /* If we are positioned at a ';', then skip it. */
3058 {
3059 /* Obsolete flags that used to indicate the presence of
3060 constructors and/or destructors. */
3062 }
3071 /* The next number is the type number of the base class (possibly
3072 our own class) which supplies the vtable for this class. */
3079 else
3080 {
3081 debug_type vtype;
3089 ;
3091 {
3094 }
3099 }
3102 }
3104 /* Read a definition of an array type. */
3106 static debug_type
3108 PTR dhandle;
3111 bfd_boolean stringp;
3112 {
3116 debug_type index_type;
3117 bfd_boolean adjustable;
3119 debug_type element_type;
3121 /* Format of an array type:
3122 "ar<index type>;lower;upper;<array_contents_type>".
3123 OS9000: "arlower,upper;<array_contents_type>".
3125 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
3126 for these, produce a type like float[][]. */
3130 /* FIXME: gdb checks os9k_stabs here. */
3132 /* If the index type is type 0, we take it as int. */
3137 {
3140 {
3144 }
3146 }
3147 else
3148 {
3151 }
3154 {
3157 }
3163 {
3166 }
3170 {
3173 }
3177 {
3180 }
3184 {
3187 }
3196 {
3199 }
3203 }
3205 /* This struct holds information about files we have seen using
3206 N_BINCL. */
3208 struct bincl_file
3209 {
3210 /* The next N_BINCL file. */
3212 /* The next N_BINCL on the stack. */
3214 /* The file name. */
3216 /* The hash value. */
3217 bfd_vma hash;
3218 /* The file index. */
3220 /* The list of types defined in this file. */
3222 };
3224 /* Start a new N_BINCL file, pushing it onto the stack. */
3226 static void
3230 bfd_vma hash;
3231 {
3250 }
3252 /* Finish an N_BINCL file, at an N_EINCL, popping the name off the
3253 stack. */
3258 {
3271 }
3273 /* Handle an N_EXCL: get the types from the corresponding N_BINCL. */
3275 static bfd_boolean
3279 bfd_vma hash;
3280 {
3293 {
3297 }
3302 }
3304 /* Handle a variable definition. gcc emits variable definitions for a
3305 block before the N_LBRAC, so we must hold onto them until we see
3306 it. The SunPRO compiler emits variable definitions after the
3307 N_LBRAC, so we can call debug_record_variable immediately. */
3309 static bfd_boolean
3311 PTR dhandle;
3314 debug_type type;
3316 bfd_vma val;
3317 {
3336 }
3338 /* Emit pending variable definitions. This is called after we see the
3339 N_LBRAC that starts the block. */
3341 static bfd_boolean
3343 PTR dhandle;
3345 {
3350 {
3359 }
3364 }
3366 /* Find the slot for a type in the database. */
3372 {
3381 {
3384 }
3386 {
3389 }
3394 {
3396 {
3399 }
3402 }
3404 {
3407 }
3410 }
3412 /* Find a type given a type number. If the type has not been
3413 allocated yet, create an indirect type. */
3415 static debug_type
3417 PTR dhandle;
3420 {
3424 {
3425 /* A negative type number indicates an XCOFF builtin type. */
3427 }
3437 }
3439 /* Record that a given type number refers to a given type. */
3441 static bfd_boolean
3443 PTR dhandle ATTRIBUTE_UNUSED;
3446 debug_type type;
3447 {
3454 /* gdb appears to ignore type redefinitions, so we do as well. */
3459 }
3461 /* Return an XCOFF builtin type. */
3463 static debug_type
3465 PTR dhandle;
3468 {
3469 debug_type rettype;
3473 {
3476 }
3481 {
3483 /* The size of this and all the other types are fixed, defined
3484 by the debugging format. */
3528 /* IEEE single precision (32 bit). */
3533 /* IEEE double precision (64 bit). */
3538 /* This is an IEEE double on the RS/6000, and different machines
3539 with different sizes for "long double" should use different
3540 negative type numbers. See stabs.texinfo. */
3561 /* FIXME */
3566 /* FIXME */
3587 /* Complex type consisting of two IEEE single precision values. */
3592 /* Complex type consisting of two IEEE double precision values. */
3609 /* FIXME */
3631 }
3638 }
3640 /* Find or create a tagged type. */
3642 static debug_type
3644 PTR dhandle;
3649 {
3651 debug_type dtype;
3656 /* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same
3657 namespace. This is right for C, and I don't know how to handle
3658 other languages. FIXME. */
3661 {
3664 }
3666 /* We need to allocate an entry on the undefined tag list. */
3668 {
3671 {
3676 }
3677 }
3679 {
3689 }
3692 }
3693 \f
3694 /* In order to get the correct argument types for a stubbed method, we
3695 need to extract the argument types from a C++ mangled string.
3696 Since the argument types can refer back to the return type, this
3697 means that we must demangle the entire physical name. In gdb this
3698 is done by calling cplus_demangle and running the results back
3699 through the C++ expression parser. Since we have no expression
3700 parser, we must duplicate much of the work of cplus_demangle here.
3702 We assume that GNU style demangling is used, since this is only
3703 done for method stubs, and only g++ should output that form of
3704 debugging information. */
3706 /* This structure is used to hold a pointer to type information which
3707 demangling a string. */
3709 struct stab_demangle_typestring
3710 {
3711 /* The start of the type. This is not null terminated. */
3713 /* The length of the type. */
3715 };
3717 /* This structure is used to hold information while demangling a
3718 string. */
3720 struct stab_demangle_info
3721 {
3722 /* The debugging information handle. */
3723 PTR dhandle;
3724 /* The stab information handle. */
3726 /* The array of arguments we are building. */
3728 /* Whether the method takes a variable number of arguments. */
3729 bfd_boolean varargs;
3730 /* The array of types we have remembered. */
3732 /* The number of typestrings. */
3734 /* The number of typestring slots we have allocated. */
3736 };
3738 static void stab_bad_demangle
3740 static unsigned int stab_demangle_count
3742 static bfd_boolean stab_demangle_get_count
3744 static bfd_boolean stab_demangle_prefix
3746 static bfd_boolean stab_demangle_function_name
3748 static bfd_boolean stab_demangle_signature
3750 static bfd_boolean stab_demangle_qualified
3752 static bfd_boolean stab_demangle_template
3754 static bfd_boolean stab_demangle_class
3756 static bfd_boolean stab_demangle_args
3758 bfd_boolean *));
3759 static bfd_boolean stab_demangle_arg
3762 static bfd_boolean stab_demangle_type
3764 static bfd_boolean stab_demangle_fund_type
3766 static bfd_boolean stab_demangle_remember_type
3769 /* Warn about a bad demangling. */
3771 static void
3774 {
3776 }
3778 /* Get a count from a stab string. */
3780 static unsigned int
3783 {
3788 {
3792 }
3794 }
3796 /* Require a count in a string. The count may be multiple digits, in
3797 which case it must end in an underscore. */
3799 static bfd_boolean
3803 {
3810 {
3816 do
3817 {
3821 }
3824 {
3827 }
3828 }
3831 }
3833 /* This function demangles a physical name, returning a NULL
3834 terminated array of argument types. */
3838 PTR dhandle;
3843 {
3856 /* cplus_demangle checks for special GNU mangled forms, but we can't
3857 see any of them in mangled method argument types. */
3863 {
3866 }
3877 error_return:
3881 }
3883 /* Demangle the prefix of the mangled name. */
3885 static bfd_boolean
3890 {
3894 /* cplus_demangle checks for global constructors and destructors,
3895 but we can't see them in mangled argument types. */
3899 else
3900 {
3901 /* Look for `__'. */
3903 do
3908 {
3911 }
3915 /* We found `__'; move ahead to the last contiguous `__' pair. */
3919 }
3925 {
3926 /* This is a GNU style constructor name. */
3929 }
3933 {
3934 /* Look for the `__' that separates the prefix from the
3935 signature. */
3940 {
3943 }
3946 }
3948 {
3949 /* The name doesn't start with `__', but it does contain `__'. */
3951 }
3952 else
3953 {
3956 }
3957 /*NOTREACHED*/
3958 }
3960 /* Demangle a function name prefix. The scan argument points to the
3961 double underscore which separates the function name from the
3962 signature. */
3964 static bfd_boolean
3969 {
3972 /* The string from *pp to scan is the name of the function. We
3973 don't care about the name, since we just looking for argument
3974 types. However, for conversion operators, the name may include a
3975 type which we must remember in order to handle backreferences. */
3983 {
3986 /* This is a type conversion operator. */
3990 }
3995 {
3998 /* This is a type conversion operator. */
4002 }
4005 }
4007 /* Demangle the signature. This is where the argument types are
4008 found. */
4010 static bfd_boolean
4014 {
4026 {
4028 {
4039 /* Static member function. FIXME: Can this happen? */
4046 /* Const member function. */
4064 /* Function. I don't know if this actually happens with g++
4065 output. */
4074 /* Template. */
4085 /* At the outermost level, we cannot have a return type
4086 specified, so if we run into another '_' at this point we
4087 are dealing with a mangled name that is either bogus, or
4088 has been mangled by some algorithm we don't know how to
4089 deal with. So just reject the entire demangling. */
4094 /* Assume we have stumbled onto the first outermost function
4095 argument token, and start processing args. */
4100 }
4103 {
4107 }
4108 }
4111 {
4112 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
4113 bar__3fooi is 'foo::bar(int)'. We get here when we find the
4114 first case, and need to ensure that the '(void)' gets added
4115 to the current declp. */
4118 }
4121 }
4123 /* Demangle a qualified name, such as "Q25Outer5Inner" which is the
4124 mangled form of "Outer::Inner". */
4126 static bfd_boolean
4131 {
4135 debug_type context;
4140 {
4142 /* GNU mangled name with more than 9 classes. The count is
4143 preceded by an underscore (to distinguish it from the <= 9
4144 case) and followed by an underscore. */
4147 {
4150 }
4155 {
4158 }
4165 /* Skip an optional underscore after the count. */
4175 }
4179 /* Pick off the names. */
4181 {
4185 {
4193 {
4196 DEBUG_KIND_CLASS);
4200 }
4201 }
4202 else
4203 {
4208 {
4211 }
4214 {
4224 {
4227 /* Try to find the type by looking through the
4228 fields of context until we find a field with the
4229 same type. This ought to work for a class
4230 defined within a class, but it won't work for,
4231 e.g., an enum defined within a class. stabs does
4232 not give us enough information to figure out the
4233 latter case. */
4238 {
4239 debug_type ft;
4247 {
4250 }
4251 }
4254 }
4257 {
4258 /* We have to fall back on finding the type by name.
4259 If there are more types to come, then this must
4260 be a class. Otherwise, it could be anything. */
4263 {
4268 name);
4270 }
4273 {
4278 ? DEBUG_KIND_ILLEGAL
4282 }
4283 }
4284 }
4287 }
4288 }
4294 }
4296 /* Demangle a template. If PNAME is not NULL, this sets *PNAME to a
4297 string representation of the template. */
4299 static bfd_boolean
4304 {
4312 /* Skip the template name. */
4315 {
4318 }
4321 /* Get the size of the parameter list. */
4323 {
4326 }
4329 {
4331 {
4332 /* This is a type parameter. */
4336 }
4337 else
4338 {
4341 bfd_boolean done;
4351 /* This is a value parameter. */
4357 {
4359 {
4406 /* Assume it's a user defined integral type. */
4410 }
4411 }
4414 {
4419 }
4421 {
4428 {
4431 }
4432 }
4434 {
4439 {
4442 }
4443 }
4445 {
4451 {
4455 }
4457 {
4461 }
4462 }
4464 {
4468 {
4471 }
4473 }
4474 }
4475 }
4477 /* We can translate this to a string fairly easily by invoking the
4478 regular demangling routine. */
4480 {
4497 {
4502 }
4504 /* Eliminating all spaces, except those between > characters,
4505 makes it more likely that the demangled name will match the
4506 name which g++ used as the structure name. */
4515 }
4518 }
4520 /* Demangle a class name. */
4522 static bfd_boolean
4527 {
4535 {
4538 }
4546 }
4548 /* Demangle function arguments. If the pargs argument is not NULL, it
4549 is set to a NULL terminated array holding the arguments. */
4551 static bfd_boolean
4557 {
4565 {
4568 }
4572 {
4574 {
4583 else
4584 {
4586 {
4589 }
4590 }
4593 {
4596 }
4599 {
4602 }
4604 {
4610 }
4611 }
4612 else
4613 {
4616 }
4617 }
4623 {
4627 }
4630 }
4632 /* Demangle a single argument. */
4634 static bfd_boolean
4641 {
4643 debug_type type;
4652 {
4657 {
4661 }
4664 }
4667 }
4669 /* Demangle a type. If the ptype argument is not NULL, *ptype is set
4670 to the newly allocated type. */
4672 static bfd_boolean
4677 {
4683 {
4686 /* A pointer type. */
4695 /* A reference type. */
4704 /* An array. */
4705 {
4711 {
4713 {
4716 }
4720 }
4722 {
4725 }
4731 {
4732 debug_type int_type;
4739 }
4740 }
4744 /* A back reference to a remembered type. */
4745 {
4751 {
4754 }
4756 {
4759 }
4763 }
4767 /* A function. */
4768 {
4770 bfd_boolean varargs;
4782 {
4783 /* cplus_demangle will accept a function without a return
4784 type, but I don't know when that will happen, or what
4785 to do if it does. */
4788 }
4794 varargs);
4796 }
4801 {
4805 bfd_boolean varargs;
4817 {
4820 {
4823 }
4828 {
4832 DEBUG_KIND_CLASS);
4835 }
4836 }
4838 {
4844 }
4845 else
4846 {
4849 }
4852 {
4854 {
4857 }
4859 {
4862 }
4864 {
4867 }
4877 }
4880 {
4883 }
4890 {
4894 else
4895 {
4896 /* FIXME: We have no way to record constp or
4897 volatilep. */
4900 }
4901 }
4902 }
4920 {
4926 }
4933 }
4936 }
4938 /* Demangle a fundamental type. If the ptype argument is not NULL,
4939 *ptype is set to the newly allocated type. */
4941 static bfd_boolean
4946 {
4949 bfd_boolean done;
4960 {
4962 {
4986 }
4987 }
4990 {
4993 /* cplus_demangle permits this, but I don't know what it means. */
4999 {
5003 }
5009 {
5011 (unsignedp
5016 }
5022 {
5024 (unsignedp
5029 }
5035 {
5037 (unsignedp
5042 }
5048 {
5050 (unsignedp
5055 }
5061 {
5065 }
5071 {
5073 (unsignedp
5075 : (signedp
5080 }
5086 {
5090 }
5096 {
5100 }
5106 {
5110 }
5116 {
5120 }
5127 {
5130 }
5131 /* Fall through. */
5134 {
5140 {
5147 {
5148 /* FIXME: It is probably incorrect to assume that
5149 undefined types are tagged types. */
5152 DEBUG_KIND_ILLEGAL);
5155 }
5156 }
5157 }
5161 {
5168 {
5171 DEBUG_KIND_CLASS);
5175 }
5176 }
5182 }
5185 {
5190 }
5193 }
5195 /* Remember a type string in a demangled string. */
5197 static bfd_boolean
5202 {
5204 {
5210 }
5217 }