Remove obsolete stabs.7 manual page.
authorSascha Wildner <saw@online.de>
Fri, 23 Mar 2018 08:15:41 +0000 (09:15 +0100)
committerSascha Wildner <saw@online.de>
Fri, 23 Mar 2018 09:19:13 +0000 (10:19 +0100)
Makefile_upgrade.inc
gnu/usr.bin/gdb/gdb/Makefile
gnu/usr.bin/gdb/gdb/stabs.7 [deleted file]

index 881f6db..046c528 100644 (file)
@@ -3379,6 +3379,7 @@ TO_REMOVE+=/etc/periodic/daily/470.status-named
 TO_REMOVE+=/etc/periodic/daily/430.status-rwho
 TO_REMOVE+=/etc/mtree/BSD.local.dist
 TO_REMOVE+=/usr/share/man/man9/devfs_clone_bitmap_fff.9.gz
+TO_REMOVE+=/usr/share/man/man7/stabs.7.gz
 
 .if !defined(WANT_INSTALLER)
 TO_REMOVE+=/usr/sbin/dfuibe_installer
index 32e83d8..761d18d 100644 (file)
@@ -1,5 +1,5 @@
 PROG=  gdb
-MAN=   gdb.1 gdbint.7 stabs.7
+MAN=   gdb.1 gdbint.7
 
 CFLAGS+= -I${.OBJDIR}/../libgdb -I${.CURDIR}/../libgdb -I${.CURDIR}/..
 CFLAGS+= -I${BASEDIR}/include
diff --git a/gnu/usr.bin/gdb/gdb/stabs.7 b/gnu/usr.bin/gdb/gdb/stabs.7
deleted file mode 100644 (file)
index 1ada37c..0000000
+++ /dev/null
@@ -1,4354 +0,0 @@
-.\" Automatically generated by Pod::Man 2.27 (Pod::Simple 3.28)
-.\"
-.\" Standard preamble:
-.\" ========================================================================
-.de Sp \" Vertical space (when we can't use .PP)
-.if t .sp .5v
-.if n .sp
-..
-.de Vb \" Begin verbatim text
-.ft CW
-.nf
-.ne \\$1
-..
-.de Ve \" End verbatim text
-.ft R
-.fi
-..
-.\" Set up some character translations and predefined strings.  \*(-- will
-.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left
-.\" double quote, and \*(R" will give a right double quote.  \*(C+ will
-.\" give a nicer C++.  Capital omega is used to do unbreakable dashes and
-.\" therefore won't be available.  \*(C` and \*(C' expand to `' in nroff,
-.\" nothing in troff, for use with C<>.
-.tr \(*W-
-.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
-.ie n \{\
-.    ds -- \(*W-
-.    ds PI pi
-.    if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
-.    if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\"  diablo 12 pitch
-.    ds L" ""
-.    ds R" ""
-.    ds C` ""
-.    ds C' ""
-'br\}
-.el\{\
-.    ds -- \|\(em\|
-.    ds PI \(*p
-.    ds L" ``
-.    ds R" ''
-.    ds C`
-.    ds C'
-'br\}
-.\"
-.\" Escape single quotes in literal strings from groff's Unicode transform.
-.ie \n(.g .ds Aq \(aq
-.el       .ds Aq '
-.\"
-.\" If the F register is turned on, we'll generate index entries on stderr for
-.\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index
-.\" entries marked with X<> in POD.  Of course, you'll have to process the
-.\" output yourself in some meaningful fashion.
-.\"
-.\" Avoid warning from groff about undefined register 'F'.
-.de IX
-..
-.nr rF 0
-.if \n(.g .if rF .nr rF 1
-.if (\n(rF:(\n(.g==0)) \{
-.    if \nF \{
-.        de IX
-.        tm Index:\\$1\t\\n%\t"\\$2"
-..
-.        if !\nF==2 \{
-.            nr % 0
-.            nr F 2
-.        \}
-.    \}
-.\}
-.rr rF
-.\"
-.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
-.\" Fear.  Run.  Save yourself.  No user-serviceable parts.
-.    \" fudge factors for nroff and troff
-.if n \{\
-.    ds #H 0
-.    ds #V .8m
-.    ds #F .3m
-.    ds #[ \f1
-.    ds #] \fP
-.\}
-.if t \{\
-.    ds #H ((1u-(\\\\n(.fu%2u))*.13m)
-.    ds #V .6m
-.    ds #F 0
-.    ds #[ \&
-.    ds #] \&
-.\}
-.    \" simple accents for nroff and troff
-.if n \{\
-.    ds ' \&
-.    ds ` \&
-.    ds ^ \&
-.    ds , \&
-.    ds ~ ~
-.    ds /
-.\}
-.if t \{\
-.    ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u"
-.    ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u'
-.    ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u'
-.    ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u'
-.    ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u'
-.    ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u'
-.\}
-.    \" troff and (daisy-wheel) nroff accents
-.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V'
-.ds 8 \h'\*(#H'\(*b\h'-\*(#H'
-.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#]
-.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H'
-.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u'
-.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#]
-.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#]
-.ds ae a\h'-(\w'a'u*4/10)'e
-.ds Ae A\h'-(\w'A'u*4/10)'E
-.    \" corrections for vroff
-.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u'
-.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u'
-.    \" for low resolution devices (crt and lpr)
-.if \n(.H>23 .if \n(.V>19 \
-\{\
-.    ds : e
-.    ds 8 ss
-.    ds o a
-.    ds d- d\h'-1'\(ga
-.    ds D- D\h'-1'\(hy
-.    ds th \o'bp'
-.    ds Th \o'LP'
-.    ds ae ae
-.    ds Ae AE
-.\}
-.rm #[ #] #H #V #F C
-.\" ========================================================================
-.\"
-.IX Title "STABS 7"
-.TH STABS 7 "2015-04-03" "perl v5.18.4" "DragonFly Miscellaneous Information Manual"
-.\" For nroff, turn off justification.  Always turn off hyphenation; it makes
-.\" way too many mistakes in technical documents.
-.if n .ad l
-.nh
-.SH "NAME"
-STABS debugging format \- Conversion of stabs.info
-.ie n .SH "The ""stabs"" representation of debugging information"
-.el .SH "The ``stabs'' representation of debugging information"
-.IX Header "The stabs representation of debugging information"
-* Menu:
-.PP
-Overview of stabs: see \*(L"Overview\*(R"
-.PP
-Encoding of the structure of the program: see \*(L"Program Structure\*(R"
-.PP
-Constants: see \*(L"Constants\*(R"
-.PP
-See also \*(L"Variables\*(R"
-.PP
-Type definitions: see \*(L"Types\*(R"
-.PP
-Representation of #define and #undef: see \*(L"Macro define and undefine\*(R"
-.PP
-Symbol information in symbol tables: see \*(L"Symbol Tables\*(R"
-.PP
-Stabs specific to \*(C+: see \*(L"Cplusplus\*(R"
-.PP
-Symbol types in a.out files: see \*(L"Stab Types\*(R"
-.PP
-Table of symbol descriptors: see \*(L"Symbol Descriptors\*(R"
-.PP
-Table of type descriptors: see \*(L"Type Descriptors\*(R"
-.PP
-Reference information by stab type: see \*(L"Expanded Reference\*(R"
-.PP
-Questions and anomalies: see \*(L"Questions\*(R"
-.PP
-In some object file formats, stabs are: see \*(L"Stab Sections\*(R"
-.PP
-in sections.
-The license for this documentation: see \*(L"\s-1GNU\s0 Free Documentation License\*(R"
-.PP
-Index of symbolic stab symbol type names.: see \*(L"Symbol Types Index\*(R"
-.SS "1 Overview of Stabs"
-.IX Subsection "1 Overview of Stabs"
-\&\*(L"Stabs\*(R" refers to a format for information that describes a program to
-a debugger.  This format was apparently invented by Peter Kessler at
-the University of California at Berkeley, for the `\fBpdx\fR' Pascal
-debugger; the format has spread widely since then.
-.PP
-This document is one of the few published sources of documentation on
-stabs.  It is believed to be comprehensive for stabs used by C.  The
-lists of symbol descriptors (see \*(L"Symbol Descriptors\*(R") and type
-descriptors (see \*(L"Type Descriptors\*(R") are believed to be completely
-comprehensive.  Stabs for COBOL-specific features and for variant
-records (used by Pascal and Modula\-2) are poorly documented here.
-.PP
-Other sources of information on stabs are `Dbx and Dbxtool
-Interfaces', 2nd edition, by Sun, 1988, and `\s-1AIX\s0 Version 3.2 Files
-Reference', Fourth Edition, September 1992, \*(L"dbx Stabstring Grammar\*(R" in
-the a.out section, page 2\-31.  This document is believed to incorporate
-the information from those two sources except where it explicitly
-directs you to them for more information.
-.PP
-* Menu:
-.PP
-Overview of debugging information flow: see \*(L"Flow\*(R"
-.PP
-Overview of stab format: see \*(L"Stabs Format\*(R"
-.PP
-The string field: see \*(L"String Field\*(R"
-.PP
-A simple example in C source: see \*(L"C Example\*(R"
-.PP
-The simple example at the assembly level: see \*(L"Assembly Code\*(R"
-.PP
-\&\fB1.1 Overview of Debugging Information Flow\fR
-.PP
-The \s-1GNU C\s0 compiler compiles C source in a `\fB.c\fR' file into assembly
-language in a `\fB.s\fR' file, which the assembler translates into a `\fB.o\fR'
-file, which the linker combines with other `\fB.o\fR' files and libraries to
-produce an executable file.
-.PP
-With the `\fB\-g\fR' option, \s-1GCC\s0 puts in the `\fB.s\fR' file additional debugging
-information, which is slightly transformed by the assembler and linker,
-and carried through into the final executable.  This debugging
-information describes features of the source file like line numbers,
-the types and scopes of variables, and function names, parameters, and
-scopes.
-.PP
-For some object file formats, the debugging information is
-encapsulated in assembler directives known collectively as \*(L"stab\*(R"
-(symbol table) directives, which are interspersed with the generated
-code.  Stabs are the native format for debugging information in the
-a.out and \s-1XCOFF\s0 object file formats.  The \s-1GNU\s0 tools can also emit stabs
-in the \s-1COFF\s0 and \s-1ECOFF\s0 object file formats.
-.PP
-The assembler adds the information from stabs to the symbol
-information it places by default in the symbol table and the string
-table of the `\fB.o\fR' file it is building.  The linker consolidates the `\fB.o\fR'
-files into one executable file, with one symbol table and one string
-table.  Debuggers use the symbol and string tables in the executable as
-a source of debugging information about the program.
-.PP
-\&\fB1.2 Overview of Stab Format\fR
-.PP
-There are three overall formats for stab assembler directives,
-differentiated by the first word of the stab.  The name of the directive
-describes which combination of four possible data fields follows.  It is
-either `\fB.stabs\fR' (string), `\fB.stabn\fR' (number), or `\fB.stabd\fR' (dot).  \s-1IBM\s0's
-\&\s-1XCOFF\s0 assembler uses `\fB.stabx\fR' (and some other directives such as
-`\fB.file\fR' and `\fB.bi\fR') instead of `\fB.stabs\fR', `\fB.stabn\fR' or `\fB.stabd\fR'.
-.PP
-The overall format of each class of stab is:
-.PP
-\&.stabs \*(L"\s-1STRING\*(R",TYPE,OTHER,DESC,VALUE
-\&\s0.stabn \s-1TYPE,OTHER,DESC,VALUE
-\&\s0.stabd \s-1TYPE,OTHER,DESC
-\&\s0.stabx \*(L"\s-1STRING\*(R",VALUE,TYPE,SDB\-TYPE\s0
-.PP
-For `\fB.stabn\fR' and `\fB.stabd\fR', there is no \s-1STRING \s0(the `\fBn_strx\fR' field is
-zero; see see \*(L"Symbol Tables\*(R").  For `\fB.stabd\fR', the \s-1VALUE\s0 field is
-implicit and has the value of the current file location.  For `\fB.stabx\fR',
-the SDB-TYPE field is unused for stabs and can always be set to zero.
-The \s-1OTHER\s0 field is almost always unused and can be set to zero.
-.PP
-The number in the \s-1TYPE\s0 field gives some basic information about
-which type of stab this is (or whether it _is_ a stab, as opposed to an
-ordinary symbol).  Each valid type number defines a different stab
-type; further, the stab type defines the exact interpretation of, and
-possible values for, any remaining \s-1STRING, DESC,\s0 or \s-1VALUE\s0 fields
-present in the stab.  see \*(L"Stab Types\*(R", for a list in numeric order
-of the valid \s-1TYPE\s0 field values for stab directives.
-.PP
-\&\fB1.3 The String Field\fR
-.PP
-For most stabs the string field holds the meat of the debugging
-information.  The flexible nature of this field is what makes stabs
-extensible.  For some stab types the string field contains only a name.
-For other stab types the contents can be a great deal more complex.
-.PP
-The overall format of the string field for most stab types is:
-.PP
-\&\*(L"\s-1NAME:SYMBOL\-DESCRIPTOR\s0 TYPE-INFORMATION\*(R"
-.PP
-\&\s-1NAME\s0 is the name of the symbol represented by the stab; it can
-contain a pair of colons (see \*(L"Nested Symbols\*(R").  \s-1NAME\s0 can be
-omitted, which means the stab represents an unnamed object.  For
-example, `\fB:t10=*2\fR' defines type 10 as a pointer to type 2, but does not
-give the type a name.  Omitting the \s-1NAME\s0 field is supported by \s-1AIX\s0 dbx
-and \s-1GDB\s0 after about version 4.8, but not other debuggers.  \s-1GCC\s0
-sometimes uses a single space as the name instead of omitting the name
-altogether; apparently that is supported by most debuggers.
-.PP
-The SYMBOL-DESCRIPTOR following the `\fB:\fR' is an alphabetic character
-that tells more specifically what kind of symbol the stab represents.
-If the SYMBOL-DESCRIPTOR is omitted, but type information follows, then
-the stab represents a local variable.  For a list of symbol
-descriptors, see see \*(L"Symbol Descriptors\*(R".  The `\fBc\fR' symbol descriptor
-is an exception in that it is not followed by type information.  *Note
-Constants::.
-.PP
-TYPE-INFORMATION is either a TYPE-NUMBER, or `\fBTYPE\-NUMBER=\fR'.  A
-TYPE-NUMBER alone is a type reference, referring directly to a type
-that has already been defined.
-.PP
-The `\fBTYPE\-NUMBER=\fR' form is a type definition, where the number
-represents a new type which is about to be defined.  The type
-definition may refer to other types by number, and those type numbers
-may be followed by `\fB=\fR' and nested definitions.  Also, the Lucid
-compiler will repeat `\fBTYPE\-NUMBER=\fR' more than once if it wants to
-define several type numbers at once.
-.PP
-In a type definition, if the character that follows the equals sign
-is non-numeric then it is a TYPE-DESCRIPTOR, and tells what kind of
-type is about to be defined.  Any other values following the
-TYPE-DESCRIPTOR vary, depending on the TYPE-DESCRIPTOR.  *Note Type
-Descriptors::, for a list of TYPE-DESCRIPTOR values.  If a number
-follows the `\fB=\fR' then the number is a TYPE-REFERENCE.  For a full
-description of types, see \*(L"Types\*(R".
-.PP
-A TYPE-NUMBER is often a single number.  The \s-1GNU\s0 and Sun tools
-additionally permit a TYPE-NUMBER to be a pair
-(\s-1FILE\-NUMBER,FILETYPE\-NUMBER\s0) (the parentheses appear in the string,
-and serve to distinguish the two cases).  The FILE-NUMBER is 0 for the
-base source file, 1 for the first included file, 2 for the next, and so
-on.  The FILETYPE-NUMBER is a number starting with 1 which is
-incremented for each new type defined in the file.  (Separating the
-file number and the type number permits the `\fBN_BINCL\fR' optimization to
-succeed more often; see see \*(L"Include Files\*(R").
-.PP
-There is an \s-1AIX\s0 extension for type attributes.  Following the `\fB=\fR'
-are any number of type attributes.  Each one starts with `\fB@\fR' and ends
-with `\fB;\fR'.  Debuggers, including \s-1AIX\s0's dbx and \s-1GDB 4.10,\s0 skip any type
-attributes they do not recognize.  \s-1GDB 4.9\s0 and other versions of dbx
-may not do this.  Because of a conflict with \*(C+ (see \*(L"Cplusplus\*(R"),
-new attributes should not be defined which begin with a digit, `\fB(\fR', or
-`\fB\-\fR'; \s-1GDB\s0 may be unable to distinguish those from the \*(C+ type
-descriptor `\fB@\fR'.  The attributes are:
-.PP
-`\fBaBOUNDARY\fR'
-\&\s-1BOUNDARY\s0 is an integer specifying the alignment.  I assume it
-applies to all variables of this type.
-.PP
-`\fBpINTEGER\fR'
-Pointer class (for checking).  Not sure what this means, or how
-\&\s-1INTEGER\s0 is interpreted.
-.PP
-`\fBP\fR'
-Indicate this is a packed type, meaning that structure fields or
-array elements are placed more closely in memory, to save memory
-at the expense of speed.
-.PP
-`\fBsSIZE\fR'
-Size in bits of a variable of this type.  This is fully supported
-by \s-1GDB 4.11\s0 and later.
-.PP
-`\fBS\fR'
-Indicate that this type is a string instead of an array of
-characters, or a bitstring instead of a set.  It doesn't change
-the layout of the data being represented, but does enable the
-debugger to know which type it is.
-.PP
-`\fBV\fR'
-Indicate that this type is a vector instead of an array.  The only
-major difference between vectors and arrays is that vectors are
-passed by value instead of by reference (vector coprocessor
-extension).
-.PP
-All of this can make the string field quite long.  All versions of
-\&\s-1GDB,\s0 and some versions of dbx, can handle arbitrarily long strings.
-But many versions of dbx (or assemblers or linkers, I'm not sure which)
-cretinously limit the strings to about 80 characters, so compilers which
-must work with such systems need to split the `\fB.stabs\fR' directive into
-several `\fB.stabs\fR' directives.  Each stab duplicates every field except
-the string field.  The string field of every stab except the last is
-marked as continued with a backslash at the end (in the assembly code
-this may be written as a double backslash, depending on the assembler).
-Removing the backslashes and concatenating the string fields of each
-stab produces the original, long string.  Just to be incompatible (or so
-they don't have to worry about what the assembler does with
-backslashes), \s-1AIX\s0 can use `\fB?\fR' instead of backslash.
-.PP
-\&\fB1.4 A Simple Example in C Source\fR
-.PP
-To get the flavor of how stabs describe source information for a C
-program, let's look at the simple program:
-.PP
-\&\fImain()\fR
-{
-printf(\*(L"Hello world\*(R");
-}
-.PP
-When compiled with `\fB\-g\fR', the program above yields the following `\fB.s\fR'
-file.  Line numbers have been added to make it easier to refer to parts
-of the `\fB.s\fR' file in the description of the stabs that follows.
-.PP
-\&\fB1.5 The Simple Example at the Assembly Level\fR
-.PP
-This simple \*(L"hello world\*(R" example demonstrates several of the stab
-types used to describe C language source files.
-.PP
-1  gcc2_compiled.:
-2  .stabs \*(L"/cygint/s1/users/jcm/play/\*(R",100,0,0,Ltext0
-3  .stabs \*(L"hello.c\*(R",100,0,0,Ltext0
-4  .text
-5  Ltext0:
-6  .stabs \*(L"int:t1=r1;\-2147483648;2147483647;\*(R",128,0,0,0
-7  .stabs \*(L"char:t2=r2;0;127;\*(R",128,0,0,0
-8  .stabs \*(L"long int:t3=r1;\-2147483648;2147483647;\*(R",128,0,0,0
-9  .stabs \*(L"unsigned int:t4=r1;0;\-1;\*(R",128,0,0,0
-10 .stabs \*(L"long unsigned int:t5=r1;0;\-1;\*(R",128,0,0,0
-11 .stabs \*(L"short int:t6=r1;\-32768;32767;\*(R",128,0,0,0
-12 .stabs \*(L"long long int:t7=r1;0;\-1;\*(R",128,0,0,0
-13 .stabs \*(L"short unsigned int:t8=r1;0;65535;\*(R",128,0,0,0
-14 .stabs \*(L"long long unsigned int:t9=r1;0;\-1;\*(R",128,0,0,0
-15 .stabs \*(L"signed char:t10=r1;\-128;127;\*(R",128,0,0,0
-16 .stabs \*(L"unsigned char:t11=r1;0;255;\*(R",128,0,0,0
-17 .stabs \*(L"float:t12=r1;4;0;\*(R",128,0,0,0
-18 .stabs \*(L"double:t13=r1;8;0;\*(R",128,0,0,0
-19 .stabs \*(L"long double:t14=r1;8;0;\*(R",128,0,0,0
-20 .stabs \*(L"void:t15=15\*(R",128,0,0,0
-21      .align 4
-22 \s-1LC0:
-23      \s0.ascii \*(L"Hello, world!\e12\e0\*(R"
-24      .align 4
-25      .global _main
-26      .proc 1
-27 _main:
-28 .stabn 68,0,4,LM1
-29 \s-1LM1:
-30      \s0!#PROLOGUE# 0
-31      save \f(CW%sp\fR,\-136,%sp
-32      !#PROLOGUE# 1
-33      call _\|_\|_main,0
-34      nop
-35 .stabn 68,0,5,LM2
-36 \s-1LM2:
-37 LBB2:
-38     \s0 sethi \f(CW%h\fRi(\s-1LC0\s0),%o1
-39      or \f(CW%o1\fR,%lo(\s-1LC0\s0),%o0
-40      call _printf,0
-41      nop
-42 .stabn 68,0,6,LM3
-43 \s-1LM3:
-44 LBE2:
-45 \s0.stabn 68,0,6,LM4
-46 \s-1LM4:
-47 L1:
-48     \s0 ret
-49      restore
-50 .stabs \*(L"main:F1\*(R",36,0,0,_main
-51 .stabn 192,0,0,LBB2
-52 .stabn 224,0,0,LBE2
-.SS "2 Encoding the Structure of the Program"
-.IX Subsection "2 Encoding the Structure of the Program"
-The elements of the program structure that stabs encode include the name
-of the main function, the names of the source and include files, the
-line numbers, procedure names and types, and the beginnings and ends of
-blocks of code.
-.PP
-* Menu:
-.PP
-Indicate what the main program is: see \*(L"Main Program\*(R"
-.PP
-The path and name of the source file: see \*(L"Source Files\*(R"
-.PP
-Names of include files: see \*(L"Include Files\*(R"
-.PP
-See also \*(L"Line Numbers\*(R"
-.PP
-See also \*(L"Procedures\*(R"
-.PP
-See also \*(L"Nested Procedures\*(R"
-.PP
-See also \*(L"Block Structure\*(R"
-.PP
-Entering procedures except at the beginning.: see \*(L"Alternate Entry Points\*(R"
-.PP
-\&\fB2.1 Main Program\fR
-.PP
-Most languages allow the main program to have any name.  The `\fBN_MAIN\fR'
-stab type tells the debugger the name that is used in this program.
-Only the string field is significant; it is the name of a function
-which is the main program.  Most C compilers do not use this stab (they
-expect the debugger to assume that the name is `\fBmain\fR'), but some C
-compilers emit an `\fBN_MAIN\fR' stab for the `\fBmain\fR' function.  I'm not sure
-how \s-1XCOFF\s0 handles this.
-.PP
-\&\fB2.2 Paths and Names of the Source Files\fR
-.PP
-Before any other stabs occur, there must be a stab specifying the source
-file.  This information is contained in a symbol of stab type `\fBN_SO\fR';
-the string field contains the name of the file.  The value of the
-symbol is the start address of the portion of the text section
-corresponding to that file.
-.PP
-Some compilers use the desc field to indicate the language of the
-source file.  Sun's compilers started this usage, and the first
-constants are derived from their documentation.  Languages added by
-gcc/gdb start at 0x32 to avoid conflict with languages Sun may add in
-the future.  A desc field with a value 0 indicates that no language has
-been specified via this mechanism.
-.PP
-`\fBN_SO_AS\fR' (0x1)
-Assembly language
-.PP
-`\fBN_SO_C\fR'  (0x2)
-K&R traditional C
-.PP
-`\fBN_SO_ANSI_C\fR' (0x3)
-\&\s-1ANSI C\s0
-.PP
-`\fBN_SO_CC\fR'  (0x4)
-\&\*(C+
-.PP
-`\fBN_SO_FORTRAN\fR' (0x5)
-Fortran
-.PP
-`\fBN_SO_PASCAL\fR' (0x6)
-Pascal
-.PP
-`\fBN_SO_FORTRAN90\fR' (0x7)
-Fortran90
-.PP
-`\fBN_SO_OBJC\fR' (0x32)
-Objective-C
-.PP
-`\fBN_SO_OBJCPLUS\fR' (0x33)
-Objective\-\*(C+
-.PP
-Some compilers (for example, \s-1GCC2\s0 and SunOS4 `\fB/bin/cc\fR') also include
-the directory in which the source was compiled, in a second `\fBN_SO\fR'
-symbol preceding the one containing the file name.  This symbol can be
-distinguished by the fact that it ends in a slash.  Code from the
-`\fBcfront\fR' \*(C+ compiler can have additional `\fBN_SO\fR' symbols for
-nonexistent source files after the `\fBN_SO\fR' for the real source file;
-these are believed to contain no useful information.
-.PP
-For example:
-.PP
-\&.stabs \*(L"/cygint/s1/users/jcm/play/\*(R",100,0,0,Ltext0     # 100 is N_SO
-\&.stabs \*(L"hello.c\*(R",100,0,0,Ltext0
-\&.text
-Ltext0:
-.PP
-Instead of `\fBN_SO\fR' symbols, \s-1XCOFF\s0 uses a `\fB.file\fR' assembler directive
-which assembles to a `\fBC_FILE\fR' symbol; explaining this in detail is
-outside the scope of this document.
-.PP
-If it is useful to indicate the end of a source file, this is done
-with an `\fBN_SO\fR' symbol with an empty string for the name.  The value is
-the address of the end of the text section for the file.  For some
-systems, there is no indication of the end of a source file, and you
-just need to figure it ended when you see an `\fBN_SO\fR' for a different
-source file, or a symbol ending in `\fB.o\fR' (which at least some linkers
-insert to mark the start of a new `\fB.o\fR' file).
-.PP
-\&\fB2.3 Names of Include Files\fR
-.PP
-There are several schemes for dealing with include files: the
-traditional `\fBN_SOL\fR' approach, Sun's `\fBN_BINCL\fR' approach, and the \s-1XCOFF\s0
-`\fBC_BINCL\fR' approach (which despite the similar name has little in common
-with `\fBN_BINCL\fR').
-.PP
-An `\fBN_SOL\fR' symbol specifies which include file subsequent symbols
-refer to.  The string field is the name of the file and the value is the
-text address corresponding to the end of the previous include file and
-the start of this one.  To specify the main source file again, use an
-`\fBN_SOL\fR' symbol with the name of the main source file.
-.PP
-The `\fBN_BINCL\fR' approach works as follows.  An `\fBN_BINCL\fR' symbol
-specifies the start of an include file.  In an object file, only the
-string is significant; the linker puts data into some of the other
-fields.  The end of the include file is marked by an `\fBN_EINCL\fR' symbol
-(which has no string field).  In an object file, there is no
-significant data in the `\fBN_EINCL\fR' symbol.  `\fBN_BINCL\fR' and `\fBN_EINCL\fR' can
-be nested.
-.PP
-If the linker detects that two source files have identical stabs
-between an `\fBN_BINCL\fR' and `\fBN_EINCL\fR' pair (as will generally be the case
-for a header file), then it only puts out the stabs once.  Each
-additional occurrence is replaced by an `\fBN_EXCL\fR' symbol.  I believe the
-\&\s-1GNU\s0 linker and the Sun (both SunOS4 and Solaris) linker are the only
-ones which supports this feature.
-.PP
-A linker which supports this feature will set the value of a
-`\fBN_BINCL\fR' symbol to the total of all the characters in the stabs
-strings included in the header file, omitting any file numbers.  The
-value of an `\fBN_EXCL\fR' symbol is the same as the value of the `\fBN_BINCL\fR'
-symbol it replaces.  This information can be used to match up `\fBN_EXCL\fR'
-and `\fBN_BINCL\fR' symbols which have the same filename.  The `\fBN_EINCL\fR'
-value, and the values of the other and description fields for all
-three, appear to always be zero.
-.PP
-For the start of an include file in \s-1XCOFF,\s0 use the `\fB.bi\fR' assembler
-directive, which generates a `\fBC_BINCL\fR' symbol.  A `\fB.ei\fR' directive,
-which generates a `\fBC_EINCL\fR' symbol, denotes the end of the include
-file.  Both directives are followed by the name of the source file in
-quotes, which becomes the string for the symbol.  The value of each
-symbol, produced automatically by the assembler and linker, is the
-offset into the executable of the beginning (inclusive, as you'd
-expect) or end (inclusive, as you would not expect) of the portion of
-the \s-1COFF\s0 line table that corresponds to this include file.  `\fBC_BINCL\fR'
-and `\fBC_EINCL\fR' do not nest.
-.PP
-\&\fB2.4 Line Numbers\fR
-.PP
-An `\fBN_SLINE\fR' symbol represents the start of a source line.  The desc
-field contains the line number and the value contains the code address
-for the start of that source line.  On most machines the address is
-absolute; for stabs in sections (see \*(L"Stab Sections\*(R"), it is relative
-to the function in which the `\fBN_SLINE\fR' symbol occurs.
-.PP
-\&\s-1GNU\s0 documents `\fBN_DSLINE\fR' and `\fBN_BSLINE\fR' symbols for line numbers in
-the data or bss segments, respectively.  They are identical to
-`\fBN_SLINE\fR' but are relocated differently by the linker.  They were
-intended to be used to describe the source location of a variable
-declaration, but I believe that \s-1GCC2\s0 actually puts the line number in
-the desc field of the stab for the variable itself.  \s-1GDB\s0 has been
-ignoring these symbols (unless they contain a string field) since at
-least \s-1GDB 3.5.\s0
-.PP
-For single source lines that generate discontiguous code, such as
-flow of control statements, there may be more than one line number
-entry for the same source line.  In this case there is a line number
-entry at the start of each code range, each with the same line number.
-.PP
-\&\s-1XCOFF\s0 does not use stabs for line numbers.  Instead, it uses \s-1COFF\s0
-line numbers (which are outside the scope of this document).  Standard
-\&\s-1COFF\s0 line numbers cannot deal with include files, but in \s-1XCOFF\s0 this is
-fixed with the `\fBC_BINCL\fR' method of marking include files (*note Include
-Files::).
-.PP
-\&\fB2.5 Procedures\fR
-.PP
-All of the following stabs normally use the `\fBN_FUN\fR' symbol type.
-However, Sun's `\fBacc\fR' compiler on SunOS4 uses `\fBN_GSYM\fR' and `\fBN_STSYM\fR',
-which means that the value of the stab for the function is useless and
-the debugger must get the address of the function from the non-stab
-symbols instead.  On systems where non-stab symbols have leading
-underscores, the stabs will lack underscores and the debugger needs to
-know about the leading underscore to match up the stab and the non-stab
-symbol.  \s-1BSD\s0 Fortran is said to use `\fBN_FNAME\fR' with the same
-restriction; the value of the symbol is not useful (I'm not sure it
-really does use this, because \s-1GDB\s0 doesn't handle this and no one has
-complained).
-.PP
-A function is represented by an `\fBF\fR' symbol descriptor for a global
-(extern) function, and `\fBf\fR' for a static (local) function.  For a.out,
-the value of the symbol is the address of the start of the function; it
-is already relocated.  For stabs in \s-1ELF,\s0 the SunPRO compiler version
-2.0.1 and \s-1GCC\s0 put out an address which gets relocated by the linker.
-In a future release SunPRO is planning to put out zero, in which case
-the address can be found from the \s-1ELF \s0(non-stab) symbol.  Because
-looking things up in the \s-1ELF\s0 symbols would probably be slow, I'm not
-sure how to find which symbol of that name is the right one, and this
-doesn't provide any way to deal with nested functions, it would
-probably be better to make the value of the stab an address relative to
-the start of the file, or just absolute.  See *note \s-1ELF\s0 Linker
-Relocation:: for more information on linker relocation of stabs in \s-1ELF\s0
-files.  For \s-1XCOFF,\s0 the stab uses the `\fBC_FUN\fR' storage class and the
-value of the stab is meaningless; the address of the function can be
-found from the csect symbol (\s-1XTY_LD/XMC_PR\s0).
-.PP
-The type information of the stab represents the return type of the
-function; thus `\fBfoo:f5\fR' means that foo is a function returning type 5.
-There is no need to try to get the line number of the start of the
-function from the stab for the function; it is in the next `\fBN_SLINE\fR'
-symbol.
-.PP
-Some compilers (such as Sun's Solaris compiler) support an extension
-for specifying the types of the arguments.  I suspect this extension is
-not used for old (non-prototyped) function definitions in C.  If the
-extension is in use, the type information of the stab for the function
-is followed by type information for each argument, with each argument
-preceded by `\fB;\fR'.  An argument type of 0 means that additional arguments
-are being passed, whose types and number may vary (`\fB...\fR' in \s-1ANSI C\s0).
-\&\s-1GDB\s0 has tolerated this extension (parsed the syntax, if not necessarily
-used the information) since at least version 4.8; I don't know whether
-all versions of dbx tolerate it.  The argument types given here are not
-redundant with the symbols for the formal parameters (*note
-Parameters::); they are the types of the arguments as they are passed,
-before any conversions might take place.  For example, if a C function
-which is declared without a prototype takes a `\fBfloat\fR' argument, the
-value is passed as a `\fBdouble\fR' but then converted to a `\fBfloat\fR'.
-Debuggers need to use the types given in the arguments when printing
-values, but when calling the function they need to use the types given
-in the symbol defining the function.
-.PP
-If the return type and types of arguments of a function which is
-defined in another source file are specified (i.e., a function
-prototype in \s-1ANSI C\s0), traditionally compilers emit no stab; the only
-way for the debugger to find the information is if the source file
-where the function is defined was also compiled with debugging symbols.
-As an extension the Solaris compiler uses symbol descriptor `\fBP\fR'
-followed by the return type of the function, followed by the arguments,
-each preceded by `\fB;\fR', as in a stab with symbol descriptor `\fBf\fR' or `\fBF\fR'.
-This use of symbol descriptor `\fBP\fR' can be distinguished from its use for
-register parameters (see \*(L"Register Parameters\*(R") by the fact that it
-has symbol type `\fBN_FUN\fR'.
-.PP
-The \s-1AIX\s0 documentation also defines symbol descriptor `\fBJ\fR' as an
-internal function.  I assume this means a function nested within another
-function.  It also says symbol descriptor `\fBm\fR' is a module in Modula\-2
-or extended Pascal.
-.PP
-Procedures (functions which do not return values) are represented as
-functions returning the `\fBvoid\fR' type in C.  I don't see why this couldn't
-be used for all languages (inventing a `\fBvoid\fR' type for this purpose if
-necessary), but the \s-1AIX\s0 documentation defines `\fBI\fR', `\fBP\fR', and `\fBQ\fR' for
-internal, global, and static procedures, respectively.  These symbol
-descriptors are unusual in that they are not followed by type
-information.
-.PP
-The following example shows a stab for a function `\fBmain\fR' which
-returns type number `\fB1\fR'.  The `\fB_main\fR' specified for the value is a
-reference to an assembler label which is used to fill in the start
-address of the function.
-.PP
-\&.stabs \*(L"main:F1\*(R",36,0,0,_main      # 36 is N_FUN
-.PP
-The stab representing a procedure is located immediately following
-the code of the procedure.  This stab is in turn directly followed by a
-group of other stabs describing elements of the procedure.  These other
-stabs describe the procedure's parameters, its block local variables,
-and its block structure.
-.PP
-If functions can appear in different sections, then the debugger may
-not be able to find the end of a function.  Recent versions of \s-1GCC\s0 will
-mark the end of a function with an `\fBN_FUN\fR' symbol with an empty string
-for the name.  The value is the address of the end of the current
-function.  Without such a symbol, there is no indication of the address
-of the end of a function, and you must assume that it ended at the
-starting address of the next function or at the end of the text section
-for the program.
-.PP
-\&\fB2.6 Nested Procedures\fR
-.PP
-For any of the symbol descriptors representing procedures, after the
-symbol descriptor and the type information is optionally a scope
-specifier.  This consists of a comma, the name of the procedure, another
-comma, and the name of the enclosing procedure.  The first name is local
-to the scope specified, and seems to be redundant with the name of the
-symbol (before the `\fB:\fR').  This feature is used by \s-1GCC,\s0 and presumably
-Pascal, Modula\-2, etc., compilers, for nested functions.
-.PP
-If procedures are nested more than one level deep, only the
-immediately containing scope is specified.  For example, this code:
-.PP
-int
-foo (int x)
-{
-int bar (int y)
-{
-int baz (int z)
-{
-return x + y + z;
-}
-return baz (x + 2 * y);
-}
-return x + bar (3 * x);
-}
-.PP
-produces the stabs:
-.PP
-\&.stabs \*(L"baz:f1,baz,bar\*(R",36,0,0,_baz.15         # 36 is N_FUN
-\&.stabs \*(L"bar:f1,bar,foo\*(R",36,0,0,_bar.12
-\&.stabs \*(L"foo:F1\*(R",36,0,0,_foo
-.PP
-\&\fB2.7 Block Structure\fR
-.PP
-The program's block structure is represented by the `\fBN_LBRAC\fR' (left
-brace) and the `\fBN_RBRAC\fR' (right brace) stab types.  The variables
-defined inside a block precede the `\fBN_LBRAC\fR' symbol for most compilers,
-including \s-1GCC. \s0 Other compilers, such as the Convex, Acorn \s-1RISC\s0
-machine, and Sun `\fBacc\fR' compilers, put the variables after the `\fBN_LBRAC\fR'
-symbol.  The values of the `\fBN_LBRAC\fR' and `\fBN_RBRAC\fR' symbols are the
-start and end addresses of the code of the block, respectively.  For
-most machines, they are relative to the starting address of this source
-file.  For the Gould \s-1NP1,\s0 they are absolute.  For stabs in sections
-(see \*(L"Stab Sections\*(R"), they are relative to the function in which
-they occur.
-.PP
-The `\fBN_LBRAC\fR' and `\fBN_RBRAC\fR' stabs that describe the block scope of a
-procedure are located after the `\fBN_FUN\fR' stab that represents the
-procedure itself.
-.PP
-Sun documents the desc field of `\fBN_LBRAC\fR' and `\fBN_RBRAC\fR' symbols as
-containing the nesting level of the block.  However, dbx seems to not
-care, and \s-1GCC\s0 always sets desc to zero.
-.PP
-For \s-1XCOFF,\s0 block scope is indicated with `\fBC_BLOCK\fR' symbols.  If the
-name of the symbol is `\fB.bb\fR', then it is the beginning of the block; if
-the name of the symbol is `\fB.be\fR'; it is the end of the block.
-.PP
-\&\fB2.8 Alternate Entry Points\fR
-.PP
-Some languages, like Fortran, have the ability to enter procedures at
-some place other than the beginning.  One can declare an alternate entry
-point.  The `\fBN_ENTRY\fR' stab is for this; however, the Sun \s-1FORTRAN\s0
-compiler doesn't use it.  According to \s-1AIX\s0 documentation, only the name
-of a `\fBC_ENTRY\fR' stab is significant; the address of the alternate entry
-point comes from the corresponding external symbol.  A previous
-revision of this document said that the value of an `\fBN_ENTRY\fR' stab was
-the address of the alternate entry point, but I don't know the source
-for that information.
-.SS "3 Constants"
-.IX Subsection "3 Constants"
-The `\fBc\fR' symbol descriptor indicates that this stab represents a
-constant.  This symbol descriptor is an exception to the general rule
-that symbol descriptors are followed by type information.  Instead, it
-is followed by `\fB=\fR' and one of the following:
-.PP
-`\fBb \s-1VALUE\s0\fR'
-Boolean constant.  \s-1VALUE\s0 is a numeric value; I assume it is 0 for
-false or 1 for true.
-.PP
-`\fBc \s-1VALUE\s0\fR'
-Character constant.  \s-1VALUE\s0 is the numeric value of the constant.
-.PP
-`\fBe TYPE-INFORMATION , \s-1VALUE\s0\fR'
-Constant whose value can be represented as integral.
-TYPE-INFORMATION is the type of the constant, as it would appear
-after a symbol descriptor (see \*(L"String Field\*(R").  \s-1VALUE\s0 is the
-numeric value of the constant.  \s-1GDB 4.9\s0 does not actually get the
-right value if \s-1VALUE\s0 does not fit in a host `\fBint\fR', but it does not
-do anything violent, and future debuggers could be extended to
-accept integers of any size (whether unsigned or not).  This
-constant type is usually documented as being only for enumeration
-constants, but \s-1GDB\s0 has never imposed that restriction; I don't
-know about other debuggers.
-.PP
-`\fBi \s-1VALUE\s0\fR'
-Integer constant.  \s-1VALUE\s0 is the numeric value.  The type is some
-sort of generic integer type (for \s-1GDB,\s0 a host `\fBint\fR'); to specify
-the type explicitly, use `\fBe\fR' instead.
-.PP
-`\fBr \s-1VALUE\s0\fR'
-Real constant.  \s-1VALUE\s0 is the real value, which can be `\fB\s-1INF\s0\fR'
-(optionally preceded by a sign) for infinity, `\fB\s-1QNAN\s0\fR' for a quiet
-NaN (not-a-number), or `\fB\s-1SNAN\s0\fR' for a signalling NaN.  If it is a
-normal number the format is that accepted by the C library function
-`\fBatof\fR'.
-.PP
-`\fBs \s-1STRING\s0\fR'
-String constant.  \s-1STRING\s0 is a string enclosed in either `'' (in
-which case `'' characters within the string are represented as
-`\fB\e\fR'' or `\fB"\fR' (in which case `\fB"\fR' characters within the string are
-represented as `\fB\e"\fR').
-.PP
-`\fBS TYPE-INFORMATION , \s-1ELEMENTS , BITS , PATTERN\s0\fR'
-Set constant.  TYPE-INFORMATION is the type of the constant, as it
-would appear after a symbol descriptor (see \*(L"String Field\*(R").
-\&\s-1ELEMENTS\s0 is the number of elements in the set (does this means how
-many bits of \s-1PATTERN\s0 are actually used, which would be redundant
-with the type, or perhaps the number of bits set in \s-1PATTERN\s0?  I
-don't get it), \s-1BITS\s0 is the number of bits in the constant (meaning
-it specifies the length of \s-1PATTERN, I\s0 think), and \s-1PATTERN\s0 is a
-hexadecimal representation of the set.  \s-1AIX\s0 documentation refers
-to a limit of 32 bytes, but I see no reason why this limit should
-exist.  This form could probably be used for arbitrary constants,
-not just sets; the only catch is that \s-1PATTERN\s0 should be understood
-to be target, not host, byte order and format.
-.PP
-The boolean, character, string, and set constants are not supported
-by \s-1GDB 4.9,\s0 but it ignores them.  \s-1GDB 4.8\s0 and earlier gave an error
-message and refused to read symbols from the file containing the
-constants.
-.PP
-The above information is followed by `\fB;\fR'.
-.SS "4 Variables"
-.IX Subsection "4 Variables"
-Different types of stabs describe the various ways that variables can be
-allocated: on the stack, globally, in registers, in common blocks,
-statically, or as arguments to a function.
-.PP
-* Menu:
-.PP
-Variables allocated on the stack.: see \*(L"Stack Variables\*(R"
-.PP
-Variables used by more than one source file.: see \*(L"Global Variables\*(R"
-.PP
-Variables in registers.: see \*(L"Register Variables\*(R"
-.PP
-Variables statically allocated together.: see \*(L"Common Blocks\*(R"
-.PP
-Variables local to one source file.: see \*(L"Statics\*(R"
-.PP
-Fortran pointer based variables.: see \*(L"Based Variables\*(R"
-.PP
-Variables for arguments to functions.: see \*(L"Parameters\*(R"
-.PP
-\&\fB4.1 Automatic Variables Allocated on the Stack\fR
-.PP
-If a variable's scope is local to a function and its lifetime is only as
-long as that function executes (C calls such variables \*(L"automatic\*(R"), it
-can be allocated in a register (see \*(L"Register Variables\*(R") or on the
-stack.
-.PP
-Each variable allocated on the stack has a stab with the symbol
-descriptor omitted.  Since type information should begin with a digit,
-`\fB\-\fR', or `\fB(\fR', only those characters precluded from being used for symbol
-descriptors.  However, the Acorn \s-1RISC\s0 machine (\s-1ARM\s0) is said to get this
-wrong: it puts out a mere type definition here, without the preceding
-`\fBTYPE\-NUMBER=\fR'.  This is a bad idea; there is no guarantee that type
-descriptors are distinct from symbol descriptors.  Stabs for stack
-variables use the `\fBN_LSYM\fR' stab type, or `\fBC_LSYM\fR' for \s-1XCOFF.\s0
-.PP
-The value of the stab is the offset of the variable within the local
-variables.  On most machines this is an offset from the frame pointer
-and is negative.  The location of the stab specifies which block it is
-defined in; see see \*(L"Block Structure\*(R".
-.PP
-For example, the following C code:
-.PP
-int
-main ()
-{
-int x;
-}
-.PP
-produces the following stabs:
-.PP
-\&.stabs \*(L"main:F1\*(R",36,0,0,_main   # 36 is N_FUN
-\&.stabs \*(L"x:1\*(R",128,0,0,\-12        # 128 is N_LSYM
-\&.stabn 192,0,0,LBB2             # 192 is N_LBRAC
-\&.stabn 224,0,0,LBE2             # 224 is N_RBRAC
-.PP
-See see \*(L"Procedures\*(R" for more information on the `\fBN_FUN\fR' stab, and
-see \*(L"Block Structure\*(R" for more information on the `\fBN_LBRAC\fR' and
-`\fBN_RBRAC\fR' stabs.
-.PP
-\&\fB4.2 Global Variables\fR
-.PP
-A variable whose scope is not specific to just one source file is
-represented by the `\fBG\fR' symbol descriptor.  These stabs use the `\fBN_GSYM\fR'
-stab type (C_GSYM for \s-1XCOFF\s0).  The type information for the stab (*note
-String Field::) gives the type of the variable.
-.PP
-For example, the following source code:
-.PP
-char g_foo = 'c';
-.PP
-yields the following assembly code:
-.PP
-\&.stabs \*(L"g_foo:G2\*(R",32,0,0,0     # 32 is N_GSYM
-\&.global _g_foo
-\&.data
-_g_foo:
-\&.byte 99
-.PP
-The address of the variable represented by the `\fBN_GSYM\fR' is not
-contained in the `\fBN_GSYM\fR' stab.  The debugger gets this information
-from the external symbol for the global variable.  In the example above,
-the `\fB.global _g_foo\fR' and `\fB_g_foo:\fR' lines tell the assembler to produce
-an external symbol.
-.PP
-Some compilers, like \s-1GCC,\s0 output `\fBN_GSYM\fR' stabs only once, where the
-variable is defined.  Other compilers, like SunOS4 /bin/cc, output a
-`\fBN_GSYM\fR' stab for each compilation unit which references the variable.
-.PP
-\&\fB4.3 Register Variables\fR
-.PP
-Register variables have their own stab type, `\fBN_RSYM\fR' (`\fBC_RSYM\fR' for
-\&\s-1XCOFF\s0), and their own symbol descriptor, `\fBr\fR'.  The stab's value is the
-number of the register where the variable data will be stored.
-.PP
-\&\s-1AIX\s0 defines a separate symbol descriptor `\fBd\fR' for floating point
-registers.  This seems unnecessary; why not just just give floating
-point registers different register numbers?  I have not verified whether
-the compiler actually uses `\fBd\fR'.
-.PP
-If the register is explicitly allocated to a global variable, but not
-initialized, as in:
-.PP
-register int g_bar asm (\*(L"%g5\*(R");
-.PP
-then the stab may be emitted at the end of the object file, with the
-other bss symbols.
-.PP
-\&\fB4.4 Common Blocks\fR
-.PP
-A common block is a statically allocated section of memory which can be
-referred to by several source files.  It may contain several variables.
-I believe Fortran is the only language with this feature.
-.PP
-A `\fBN_BCOMM\fR' stab begins a common block and an `\fBN_ECOMM\fR' stab ends
-it.  The only field that is significant in these two stabs is the
-string, which names a normal (non-debugging) symbol that gives the
-address of the common block.  According to \s-1IBM\s0 documentation, only the
-`\fBN_BCOMM\fR' has the name of the common block (even though their compiler
-actually puts it both places).
-.PP
-The stabs for the members of the common block are between the
-`\fBN_BCOMM\fR' and the `\fBN_ECOMM\fR'; the value of each stab is the offset
-within the common block of that variable.  \s-1IBM\s0 uses the `\fBC_ECOML\fR' stab
-type, and there is a corresponding `\fBN_ECOML\fR' stab type, but Sun's
-Fortran compiler uses `\fBN_GSYM\fR' instead.  The variables within a common
-block use the `\fBV\fR' symbol descriptor (I believe this is true of all
-Fortran variables).  Other stabs (at least type declarations using
-`\fBC_DECL\fR') can also be between the `\fBN_BCOMM\fR' and the `\fBN_ECOMM\fR'.
-.PP
-\&\fB4.5 Static Variables\fR
-.PP
-Initialized static variables are represented by the `\fBS\fR' and `\fBV\fR' symbol
-descriptors.  `\fBS\fR' means file scope static, and `\fBV\fR' means procedure
-scope static.  One exception: in \s-1XCOFF, IBM\s0's xlc compiler always uses
-`\fBV\fR', and whether it is file scope or not is distinguished by whether
-the stab is located within a function.
-.PP
-In a.out files, `\fBN_STSYM\fR' means the data section, `\fBN_FUN\fR' means the
-text section, and `\fBN_LCSYM\fR' means the bss section.  For those systems
-with a read-only data section separate from the text section (Solaris),
-`\fBN_ROSYM\fR' means the read-only data section.
-.PP
-For example, the source lines:
-.PP
-static const int var_const = 5;
-static int var_init = 2;
-static int var_noinit;
-.PP
-yield the following stabs:
-.PP
-\&.stabs \*(L"var_const:S1\*(R",36,0,0,_var_const      # 36 is N_FUN
-\&...
-\&.stabs \*(L"var_init:S1\*(R",38,0,0,_var_init        # 38 is N_STSYM
-\&...
-\&.stabs \*(L"var_noinit:S1\*(R",40,0,0,_var_noinit    # 40 is N_LCSYM
-.PP
-In \s-1XCOFF\s0 files, the stab type need not indicate the section;
-`\fBC_STSYM\fR' can be used for all statics.  Also, each static variable is
-enclosed in a static block.  A `\fBC_BSTAT\fR' (emitted with a `\fB.bs\fR'
-assembler directive) symbol begins the static block; its value is the
-symbol number of the csect symbol whose value is the address of the
-static block, its section is the section of the variables in that
-static block, and its name is `\fB.bs\fR'.  A `\fBC_ESTAT\fR' (emitted with a `\fB.es\fR'
-assembler directive) symbol ends the static block; its name is `\fB.es\fR'
-and its value and section are ignored.
-.PP
-In \s-1ECOFF\s0 files, the storage class is used to specify the section, so
-the stab type need not indicate the section.
-.PP
-In \s-1ELF\s0 files, for the SunPRO compiler version 2.0.1, symbol
-descriptor `\fBS\fR' means that the address is absolute (the linker relocates
-it) and symbol descriptor `\fBV\fR' means that the address is relative to the
-start of the relevant section for that compilation unit.  SunPRO has
-plans to have the linker stop relocating stabs; I suspect that their the
-debugger gets the address from the corresponding \s-1ELF \s0(not stab) symbol.
-I'm not sure how to find which symbol of that name is the right one.
-The clean way to do all this would be to have the value of a symbol
-descriptor `\fBS\fR' symbol be an offset relative to the start of the file,
-just like everything else, but that introduces obvious compatibility
-problems.  For more information on linker stab relocation, *Note \s-1ELF\s0
-Linker Relocation::.
-.PP
-\&\fB4.6 Fortran Based Variables\fR
-.PP
-Fortran (at least, the Sun and \s-1SGI\s0 dialects of \s-1FORTRAN\-77\s0) has a feature
-which allows allocating arrays with `\fBmalloc\fR', but which avoids blurring
-the line between arrays and pointers the way that C does.  In stabs
-such a variable uses the `\fBb\fR' symbol descriptor.
-.PP
-For example, the Fortran declarations
-.PP
-real foo, foo10(10), foo10_5(10,5)
-pointer (foop, foo)
-pointer (foo10p, foo10)
-pointer (foo105p, foo10_5)
-.PP
-produce the stabs
-.PP
-foo:b6
-foo10:bar3;1;10;6
-foo10_5:bar3;1;5;ar3;1;10;6
-.PP
-In this example, `\fBreal\fR' is type 6 and type 3 is an integral type
-which is the type of the subscripts of the array (probably `\fBinteger\fR').
-.PP
-The `\fBb\fR' symbol descriptor is like `\fBV\fR' in that it denotes a
-statically allocated symbol whose scope is local to a function; see
-see \*(L"Statics\*(R".  The value of the symbol, instead of being the address
-of the variable itself, is the address of a pointer to that variable.
-So in the above example, the value of the `\fBfoo\fR' stab is the address of
-a pointer to a real, the value of the `\fBfoo10\fR' stab is the address of a
-pointer to a 10\-element array of reals, and the value of the `\fBfoo10_5\fR'
-stab is the address of a pointer to a 5\-element array of 10\-element
-arrays of reals.
-.PP
-\&\fB4.7 Parameters\fR
-.PP
-Formal parameters to a function are represented by a stab (or sometimes
-two; see below) for each parameter.  The stabs are in the order in which
-the debugger should print the parameters (i.e., the order in which the
-parameters are declared in the source file).  The exact form of the stab
-depends on how the parameter is being passed.
-.PP
-Parameters passed on the stack use the symbol descriptor `\fBp\fR' and the
-`\fBN_PSYM\fR' symbol type (or `\fBC_PSYM\fR' for \s-1XCOFF\s0).  The value of the symbol
-is an offset used to locate the parameter on the stack; its exact
-meaning is machine-dependent, but on most machines it is an offset from
-the frame pointer.
-.PP
-As a simple example, the code:
-.PP
-main (argc, argv)
-int argc;
-char **argv;
-.PP
-produces the stabs:
-.PP
-\&.stabs \*(L"main:F1\*(R",36,0,0,_main                 # 36 is N_FUN
-\&.stabs \*(L"argc:p1\*(R",160,0,0,68                   # 160 is N_PSYM
-\&.stabs \*(L"argv:p20=*21=*2\*(R",160,0,0,72
-.PP
-The type definition of `\fBargv\fR' is interesting because it contains
-several type definitions.  Type 21 is pointer to type 2 (char) and
-`\fBargv\fR' (type 20) is pointer to type 21.
-.PP
-The following symbol descriptors are also said to go with `\fBN_PSYM\fR'.
-The value of the symbol is said to be an offset from the argument
-pointer (I'm not sure whether this is true or not).
-.PP
-pP (<<??>>)
-pF Fortran function parameter
-X  (function result variable)
-.PP
-* Menu:
-.PP
-See also \*(L"Register Parameters\*(R"
-.PP
-See also \*(L"Local Variable Parameters\*(R"
-.PP
-See also \*(L"Reference Parameters\*(R"
-.PP
-See also \*(L"Conformant Arrays\*(R"
-.PP
-\&\fB4.7.1 Passing Parameters in Registers\fR
-.PP
-If the parameter is passed in a register, then traditionally there are
-two symbols for each argument:
-.PP
-\&.stabs \*(L"arg:p1\*(R" . . .       ; N_PSYM
-\&.stabs \*(L"arg:r1\*(R" . . .       ; N_RSYM
-.PP
-Debuggers use the second one to find the value, and the first one to
-know that it is an argument.
-.PP
-Because that approach is kind of ugly, some compilers use symbol
-descriptor `\fBP\fR' or `\fBR\fR' to indicate an argument which is in a register.
-Symbol type `\fBC_RPSYM\fR' is used in \s-1XCOFF\s0 and `\fBN_RSYM\fR' is used otherwise.
-The symbol's value is the register number.  `\fBP\fR' and `\fBR\fR' mean the same
-thing; the difference is that `\fBP\fR' is a \s-1GNU\s0 invention and `\fBR\fR' is an \s-1IBM
-\&\s0(\s-1XCOFF\s0) invention.  As of version 4.9, \s-1GDB\s0 should handle either one.
-.PP
-There is at least one case where \s-1GCC\s0 uses a `\fBp\fR' and `\fBr\fR' pair rather
-than `\fBP\fR'; this is where the argument is passed in the argument list and
-then loaded into a register.
-.PP
-According to the \s-1AIX\s0 documentation, symbol descriptor `\fBD\fR' is for a
-parameter passed in a floating point register.  This seems
-unnecessary\*(--why not just use `\fBR\fR' with a register number which
-indicates that it's a floating point register?  I haven't verified
-whether the system actually does what the documentation indicates.
-.PP
-On the sparc and hppa, for a `\fBP\fR' symbol whose type is a structure or
-union, the register contains the address of the structure.  On the
-sparc, this is also true of a `\fBp\fR' and `\fBr\fR' pair (using Sun `\fBcc\fR') or a
-`\fBp\fR' symbol.  However, if a (small) structure is really in a register,
-`\fBr\fR' is used.  And, to top it all off, on the hppa it might be a
-structure which was passed on the stack and loaded into a register and
-for which there is a `\fBp\fR' and `\fBr\fR' pair!  I believe that symbol
-descriptor `\fBi\fR' is supposed to deal with this case (it is said to mean
-\&\*(L"value parameter by reference, indirect access\*(R"; I don't know the
-source for this information), but I don't know details or what
-compilers or debuggers use it, if any (not \s-1GDB\s0 or \s-1GCC\s0).  It is not
-clear to me whether this case needs to be dealt with differently than
-parameters passed by reference (see \*(L"Reference Parameters\*(R").
-.PP
-\&\fB4.7.2 Storing Parameters as Local Variables\fR
-.PP
-There is a case similar to an argument in a register, which is an
-argument that is actually stored as a local variable.  Sometimes this
-happens when the argument was passed in a register and then the compiler
-stores it as a local variable.  If possible, the compiler should claim
-that it's in a register, but this isn't always done.
-.PP
-If a parameter is passed as one type and converted to a smaller type
-by the prologue (for example, the parameter is declared as a `\fBfloat\fR',
-but the calling conventions specify that it is passed as a `\fBdouble\fR'),
-then \s-1GCC2 \s0(sometimes) uses a pair of symbols.  The first symbol uses
-symbol descriptor `\fBp\fR' and the type which is passed.  The second symbol
-has the type and location which the parameter actually has after the
-prologue.  For example, suppose the following C code appears with no
-prototypes involved:
-.PP
-void
-subr (f)
-float f;
-{
-.PP
-if `\fBf\fR' is passed as a double at stack offset 8, and the prologue
-converts it to a float in register number 0, then the stabs look like:
-.PP
-\&.stabs \*(L"f:p13\*(R",160,0,3,8   # 160 is `\fBN_PSYM\fR', here 13 is `\fBdouble\fR'
-\&.stabs \*(L"f:r12\*(R",64,0,3,0    # 64 is `\fBN_RSYM\fR', here 12 is `\fBfloat\fR'
-.PP
-In both stabs 3 is the line number where `\fBf\fR' is declared (*note Line
-Numbers::).
-.PP
-\&\s-1GCC,\s0 at least on the 960, has another solution to the same problem.
-It uses a single `\fBp\fR' symbol descriptor for an argument which is stored
-as a local variable but uses `\fBN_LSYM\fR' instead of `\fBN_PSYM\fR'.  In this
-case, the value of the symbol is an offset relative to the local
-variables for that function, not relative to the arguments; on some
-machines those are the same thing, but not on all.
-.PP
-On the \s-1VAX\s0 or on other machines in which the calling convention
-includes the number of words of arguments actually passed, the debugger
-(\s-1GDB\s0 at least) uses the parameter symbols to keep track of whether it
-needs to print nameless arguments in addition to the formal parameters
-which it has printed because each one has a stab.  For example, in
-.PP
-extern int fprintf (\s-1FILE\s0 *stream, char *format, ...);
-\&...
-fprintf (stdout, \*(L"%d\en\*(R", x);
-.PP
-there are stabs for `\fBstream\fR' and `\fBformat\fR'.  On most machines, the
-debugger can only print those two arguments (because it has no way of
-knowing that additional arguments were passed), but on the \s-1VAX\s0 or other
-machines with a calling convention which indicates the number of words
-of arguments, the debugger can print all three arguments.  To do so,
-the parameter symbol (symbol descriptor `\fBp\fR') (not necessarily `\fBr\fR' or
-symbol descriptor omitted symbols) needs to contain the actual type as
-passed (for example, `\fBdouble\fR' not `\fBfloat\fR' if it is passed as a double
-and converted to a float).
-.PP
-\&\fB4.7.3 Passing Parameters by Reference\fR
-.PP
-If the parameter is passed by reference (e.g., Pascal `\fB\s-1VAR\s0\fR'
-parameters), then the symbol descriptor is `\fBv\fR' if it is in the argument
-list, or `\fBa\fR' if it in a register.  Other than the fact that these
-contain the address of the parameter rather than the parameter itself,
-they are identical to `\fBp\fR' and `\fBR\fR', respectively.  I believe `\fBa\fR' is an
-\&\s-1AIX\s0 invention; `\fBv\fR' is supported by all stabs-using systems as far as I
-know.
-.PP
-\&\fB4.7.4 Passing Conformant Array Parameters\fR
-.PP
-Conformant arrays are a feature of Modula\-2, and perhaps other
-languages, in which the size of an array parameter is not known to the
-called function until run-time.  Such parameters have two stabs: a `\fBx\fR'
-for the array itself, and a `\fBC\fR', which represents the size of the
-array.  The value of the `\fBx\fR' stab is the offset in the argument list
-where the address of the array is stored (it this right?  it is a
-guess); the value of the `\fBC\fR' stab is the offset in the argument list
-where the size of the array (in elements? in bytes?) is stored.
-.SS "5 Defining Types"
-.IX Subsection "5 Defining Types"
-The examples so far have described types as references to previously
-defined types, or defined in terms of subranges of or pointers to
-previously defined types.  This chapter describes the other type
-descriptors that may follow the `\fB=\fR' in a type definition.
-.PP
-* Menu:
-.PP
-Integers, floating point, void, etc.: see \*(L"Builtin Types\*(R"
-.PP
-Pointers, sets, files, etc.: see \*(L"Miscellaneous Types\*(R"
-.PP
-Referring to a type not yet defined.: see \*(L"Cross-References\*(R"
-.PP
-A type with a specific range.: see \*(L"Subranges\*(R"
-.PP
-An aggregate type of same-typed elements.: see \*(L"Arrays\*(R"
-.PP
-Like an array but also has a length.: see \*(L"Strings\*(R"
-.PP
-Like an integer but the values have names.: see \*(L"Enumerations\*(R"
-.PP
-An aggregate type of different-typed elements.: see \*(L"Structures\*(R"
-.PP
-Giving a type a name.: see \*(L"Typedefs\*(R"
-.PP
-Different types sharing storage.: see \*(L"Unions\*(R"
-.PP
-See also \*(L"Function Types\*(R"
-.PP
-\&\fB5.1 Builtin Types\fR
-.PP
-Certain types are built in (`\fBint\fR', `\fBshort\fR', `\fBvoid\fR', `\fBfloat\fR', etc.); the
-debugger recognizes these types and knows how to handle them.  Thus,
-don't be surprised if some of the following ways of specifying builtin
-types do not specify everything that a debugger would need to know
-about the type\*(--in some cases they merely specify enough information to
-distinguish the type from other types.
-.PP
-The traditional way to define builtin types is convoluted, so new
-ways have been invented to describe them.  Sun's `\fBacc\fR' uses special
-builtin type descriptors (`\fBb\fR' and `\fBR\fR'), and \s-1IBM\s0 uses negative type
-numbers.  \s-1GDB\s0 accepts all three ways, as of version 4.8; dbx just
-accepts the traditional builtin types and perhaps one of the other two
-formats.  The following sections describe each of these formats.
-.PP
-* Menu:
-.PP
-Put on your seat belts and prepare for kludgery: see \*(L"Traditional Builtin Types\*(R"
-.PP
-Builtin types with special type descriptors: see \*(L"Builtin Type Descriptors\*(R"
-.PP
-Builtin types using negative type numbers: see \*(L"Negative Type Numbers\*(R"
-.PP
-\&\fB5.1.1 Traditional Builtin Types\fR
-.PP
-This is the traditional, convoluted method for defining builtin types.
-There are several classes of such type definitions: integer, floating
-point, and `\fBvoid\fR'.
-.PP
-* Menu:
-.PP
-See also \*(L"Traditional Integer Types\*(R"
-.PP
-See also \*(L"Traditional Other Types\*(R"
-.PP
-\&\fB5.1.1.1 Traditional Integer Types\fR
-.PP
-Often types are defined as subranges of themselves.  If the bounding
-values fit within an `\fBint\fR', then they are given normally.  For example:
-.PP
-\&.stabs \*(L"int:t1=r1;\-2147483648;2147483647;\*(R",128,0,0,0    # 128 is N_LSYM
-\&.stabs \*(L"char:t2=r2;0;127;\*(R",128,0,0,0
-.PP
-Builtin types can also be described as subranges of `\fBint\fR':
-.PP
-\&.stabs \*(L"unsigned short:t6=r1;0;65535;\*(R",128,0,0,0
-.PP
-If the lower bound of a subrange is 0 and the upper bound is \-1, the
-type is an unsigned integral type whose bounds are too big to describe
-in an `\fBint\fR'.  Traditionally this is only used for `\fBunsigned int\fR' and
-`\fBunsigned long\fR':
-.PP
-\&.stabs \*(L"unsigned int:t4=r1;0;\-1;\*(R",128,0,0,0
-.PP
-For larger types, \s-1GCC 2.4.5\s0 puts out bounds in octal, with one or
-more leading zeroes.  In this case a negative bound consists of a number
-which is a 1 bit (for the sign bit) followed by a 0 bit for each bit in
-the number (except the sign bit), and a positive bound is one which is a
-1 bit for each bit in the number (except possibly the sign bit).  All
-known versions of dbx and \s-1GDB\s0 version 4 accept this (at least in the
-sense of not refusing to process the file), but \s-1GDB 3.5\s0 refuses to read
-the whole file containing such symbols.  So \s-1GCC 2.3.3\s0 did not output the
-proper size for these types.  As an example of octal bounds, the string
-fields of the stabs for 64 bit integer types look like:
-.PP
-long int:t3=r1;001000000000000000000000;000777777777777777777777;
-long unsigned int:t5=r1;000000000000000000000000;001777777777777777777777;
-.PP
-If the lower bound of a subrange is 0 and the upper bound is
-negative, the type is an unsigned integral type whose size in bytes is
-the absolute value of the upper bound.  I believe this is a Convex
-convention for `\fBunsigned long long\fR'.
-.PP
-If the lower bound of a subrange is negative and the upper bound is
-0, the type is a signed integral type whose size in bytes is the
-absolute value of the lower bound.  I believe this is a Convex
-convention for `\fBlong long\fR'.  To distinguish this from a legitimate
-subrange, the type should be a subrange of itself.  I'm not sure whether
-this is the case for Convex.
-.PP
-\&\fB5.1.1.2 Traditional Other Types\fR
-.PP
-If the upper bound of a subrange is 0 and the lower bound is positive,
-the type is a floating point type, and the lower bound of the subrange
-indicates the number of bytes in the type:
-.PP
-\&.stabs \*(L"float:t12=r1;4;0;\*(R",128,0,0,0
-\&.stabs \*(L"double:t13=r1;8;0;\*(R",128,0,0,0
-.PP
-However, \s-1GCC\s0 writes `\fBlong double\fR' the same way it writes `\fBdouble\fR',
-so there is no way to distinguish.
-.PP
-\&.stabs \*(L"long double:t14=r1;8;0;\*(R",128,0,0,0
-.PP
-Complex types are defined the same way as floating-point types;
-there is no way to distinguish a single-precision complex from a
-double-precision floating-point type.
-.PP
-The C `\fBvoid\fR' type is defined as itself:
-.PP
-\&.stabs \*(L"void:t15=15\*(R",128,0,0,0
-.PP
-I'm not sure how a boolean type is represented.
-.PP
-\&\fB5.1.2 Defining Builtin Types Using Builtin Type Descriptors\fR
-.PP
-This is the method used by Sun's `\fBacc\fR' for defining builtin types.
-These are the type descriptors to define builtin types:
-.PP
-`\fBb \s-1SIGNED\s0 CHAR-FLAG \s-1WIDTH \s0; \s-1OFFSET \s0; \s-1NBITS \s0;\fR'
-Define an integral type.  \s-1SIGNED\s0 is `\fBu\fR' for unsigned or `\fBs\fR' for
-signed.  CHAR-FLAG is `\fBc\fR' which indicates this is a character
-type, or is omitted.  I assume this is to distinguish an integral
-type from a character type of the same size, for example it might
-make sense to set it for the C type `\fBwchar_t\fR' so the debugger can
-print such variables differently (Solaris does not do this).  Sun
-sets it on the C types `\fBsigned char\fR' and `\fBunsigned char\fR' which
-arguably is wrong.  \s-1WIDTH\s0 and \s-1OFFSET\s0 appear to be for small
-objects stored in larger ones, for example a `\fBshort\fR' in an `\fBint\fR'
-register.  \s-1WIDTH\s0 is normally the number of bytes in the type.
-\&\s-1OFFSET\s0 seems to always be zero.  \s-1NBITS\s0 is the number of bits in
-the type.
-.PP
-Note that type descriptor `\fBb\fR' used for builtin types conflicts with
-its use for Pascal space types (see \*(L"Miscellaneous Types\*(R"); they
-can be distinguished because the character following the type
-descriptor will be a digit, `\fB(\fR', or `\fB\-\fR' for a Pascal space type, or
-`\fBu\fR' or `\fBs\fR' for a builtin type.
-.PP
-`\fBw\fR'
-Documented by \s-1AIX\s0 to define a wide character type, but their
-compiler actually uses negative type numbers (*note Negative Type
-Numbers::).
-.PP
-`\fBR FP-TYPE ; \s-1BYTES \s0;\fR'
-Define a floating point type.  FP-TYPE has one of the following
-values:
-.PP
-`\fB1 (\s-1NF_SINGLE\s0)\fR'
-\&\s-1IEEE\s0 32\-bit (single precision) floating point format.
-.PP
-`\fB2 (\s-1NF_DOUBLE\s0)\fR'
-\&\s-1IEEE\s0 64\-bit (double precision) floating point format.
-.PP
-`\fB3 (\s-1NF_COMPLEX\s0)\fR'
-.PP
-`\fB4 (\s-1NF_COMPLEX16\s0)\fR'
-.PP
-`\fB5 (\s-1NF_COMPLEX32\s0)\fR'
-These are for complex numbers.  A comment in the \s-1GDB\s0 source
-describes them as Fortran `\fBcomplex\fR', `\fBdouble complex\fR', and
-`\fBcomplex*16\fR', respectively, but what does that mean?  (i.e.,
-Single precision?  Double precision?).
-.PP
-`\fB6 (\s-1NF_LDOUBLE\s0)\fR'
-Long double.  This should probably only be used for Sun format
-`\fBlong double\fR', and new codes should be used for other floating
-point formats (`\fB\s-1NF_DOUBLE\s0\fR' can be used if a `\fBlong double\fR' is
-really just an \s-1IEEE\s0 double, of course).
-.PP
-\&\s-1BYTES\s0 is the number of bytes occupied by the type.  This allows a
-debugger to perform some operations with the type even if it
-doesn't understand FP-TYPE.
-.PP
-`\fBg TYPE-INFORMATION ; \s-1NBITS\s0\fR'
-Documented by \s-1AIX\s0 to define a floating type, but their compiler
-actually uses negative type numbers (*note Negative Type
-Numbers::).
-.PP
-`\fBc TYPE-INFORMATION ; \s-1NBITS\s0\fR'
-Documented by \s-1AIX\s0 to define a complex type, but their compiler
-actually uses negative type numbers (*note Negative Type
-Numbers::).
-.PP
-The C `\fBvoid\fR' type is defined as a signed integral type 0 bits long:
-\&.stabs \*(L"void:t19=bs0;0;0\*(R",128,0,0,0
-The Solaris compiler seems to omit the trailing semicolon in this
-case.  Getting sloppy in this way is not a swift move because if a type
-is embedded in a more complex expression it is necessary to be able to
-tell where it ends.
-.PP
-I'm not sure how a boolean type is represented.
-.PP
-\&\fB5.1.3 Negative Type Numbers\fR
-.PP
-This is the method used in \s-1XCOFF\s0 for defining builtin types.  Since the
-debugger knows about the builtin types anyway, the idea of negative
-type numbers is simply to give a special type number which indicates
-the builtin type.  There is no stab defining these types.
-.PP
-There are several subtle issues with negative type numbers.
-.PP
-One is the size of the type.  A builtin type (for example the C types
-`\fBint\fR' or `\fBlong\fR') might have different sizes depending on compiler
-options, the target architecture, the \s-1ABI,\s0 etc.  This issue doesn't
-come up for \s-1IBM\s0 tools since (so far) they just target the \s-1RS/6000\s0; the
-sizes indicated below for each size are what the \s-1IBM RS/6000\s0 tools use.
-To deal with differing sizes, either define separate negative type
-numbers for each size (which works but requires changing the debugger,
-and, unless you get both \s-1AIX\s0 dbx and \s-1GDB\s0 to accept the change,
-introduces an incompatibility), or use a type attribute (*note String
-Field::) to define a new type with the appropriate size (which merely
-requires a debugger which understands type attributes, like \s-1AIX\s0 dbx or
-\&\s-1GDB\s0).  For example,
-.PP
-\&.stabs \*(L"boolean:t10=@s8;\-16\*(R",128,0,0,0
-.PP
-defines an 8\-bit boolean type, and
-.PP
-\&.stabs \*(L"boolean:t10=@s64;\-16\*(R",128,0,0,0
-.PP
-defines a 64\-bit boolean type.
-.PP
-A similar issue is the format of the type.  This comes up most often
-for floating-point types, which could have various formats (particularly
-extended doubles, which vary quite a bit even among \s-1IEEE\s0 systems).
-Again, it is best to define a new negative type number for each
-different format; changing the format based on the target system has
-various problems.  One such problem is that the Alpha has both \s-1VAX\s0 and
-\&\s-1IEEE\s0 floating types.  One can easily imagine one library using the \s-1VAX\s0
-types and another library in the same executable using the \s-1IEEE\s0 types.
-Another example is that the interpretation of whether a boolean is true
-or false can be based on the least significant bit, most significant
-bit, whether it is zero, etc., and different compilers (or different
-options to the same compiler) might provide different kinds of boolean.
-.PP
-The last major issue is the names of the types.  The name of a given
-type depends _only_ on the negative type number given; these do not
-vary depending on the language, the target system, or anything else.
-One can always define separate type numbers\*(--in the following list you
-will see for example separate `\fBint\fR' and `\fBinteger*4\fR' types which are
-identical except for the name.  But compatibility can be maintained by
-not inventing new negative type numbers and instead just defining a new
-type with a new name.  For example:
-.PP
-\&.stabs \*(L"CARDINAL:t10=\-8\*(R",128,0,0,0
-.PP
-Here is the list of negative type numbers.  The phrase \*(L"integral
-type\*(R" is used to mean twos-complement (I strongly suspect that all
-machines which use stabs use twos-complement; most machines use
-twos-complement these days).
-.PP
-`\fB\-1\fR'
-`\fBint\fR', 32 bit signed integral type.
-.PP
-`\fB\-2\fR'
-`\fBchar\fR', 8 bit type holding a character.   Both \s-1GDB\s0 and dbx on \s-1AIX\s0
-treat this as signed.  \s-1GCC\s0 uses this type whether `\fBchar\fR' is signed
-or not, which seems like a bad idea.  The \s-1AIX\s0 compiler (`\fBxlc\fR')
-seems to avoid this type; it uses \-5 instead for `\fBchar\fR'.
-.PP
-`\fB\-3\fR'
-`\fBshort\fR', 16 bit signed integral type.
-.PP
-`\fB\-4\fR'
-`\fBlong\fR', 32 bit signed integral type.
-.PP
-`\fB\-5\fR'
-`\fBunsigned char\fR', 8 bit unsigned integral type.
-.PP
-`\fB\-6\fR'
-`\fBsigned char\fR', 8 bit signed integral type.
-.PP
-`\fB\-7\fR'
-`\fBunsigned short\fR', 16 bit unsigned integral type.
-.PP
-`\fB\-8\fR'
-`\fBunsigned int\fR', 32 bit unsigned integral type.
-.PP
-`\fB\-9\fR'
-`\fBunsigned\fR', 32 bit unsigned integral type.
-.PP
-`\fB\-10\fR'
-`\fBunsigned long\fR', 32 bit unsigned integral type.
-.PP
-`\fB\-11\fR'
-`\fBvoid\fR', type indicating the lack of a value.
-.PP
-`\fB\-12\fR'
-`\fBfloat\fR', \s-1IEEE\s0 single precision.
-.PP
-`\fB\-13\fR'
-`\fBdouble\fR', \s-1IEEE\s0 double precision.
-.PP
-`\fB\-14\fR'
-`\fBlong double\fR', \s-1IEEE\s0 double precision.  The compiler claims the size
-will increase in a future release, and for binary compatibility
-you have to avoid using `\fBlong double\fR'.  I hope when they increase
-it they use a new negative type number.
-.PP
-`\fB\-15\fR'
-`\fBinteger\fR'.  32 bit signed integral type.
-.PP
-`\fB\-16\fR'
-`\fBboolean\fR'.  32 bit type.  \s-1GDB\s0 and \s-1GCC\s0 assume that zero is false,
-one is true, and other values have unspecified meaning.  I hope
-this agrees with how the \s-1IBM\s0 tools use the type.
-.PP
-`\fB\-17\fR'
-`\fBshort real\fR'.  \s-1IEEE\s0 single precision.
-.PP
-`\fB\-18\fR'
-`\fBreal\fR'.  \s-1IEEE\s0 double precision.
-.PP
-`\fB\-19\fR'
-`\fBstringptr\fR'.  see \*(L"Strings\*(R".
-.PP
-`\fB\-20\fR'
-`\fBcharacter\fR', 8 bit unsigned character type.
-.PP
-`\fB\-21\fR'
-`\fBlogical*1\fR', 8 bit type.  This Fortran type has a split
-personality in that it is used for boolean variables, but can also
-be used for unsigned integers.  0 is false, 1 is true, and other
-values are non-boolean.
-.PP
-`\fB\-22\fR'
-`\fBlogical*2\fR', 16 bit type.  This Fortran type has a split
-personality in that it is used for boolean variables, but can also
-be used for unsigned integers.  0 is false, 1 is true, and other
-values are non-boolean.
-.PP
-`\fB\-23\fR'
-`\fBlogical*4\fR', 32 bit type.  This Fortran type has a split
-personality in that it is used for boolean variables, but can also
-be used for unsigned integers.  0 is false, 1 is true, and other
-values are non-boolean.
-.PP
-`\fB\-24\fR'
-`\fBlogical\fR', 32 bit type.  This Fortran type has a split personality
-in that it is used for boolean variables, but can also be used for
-unsigned integers.  0 is false, 1 is true, and other values are
-non-boolean.
-.PP
-`\fB\-25\fR'
-`\fBcomplex\fR'.  A complex type consisting of two \s-1IEEE\s0 single-precision
-floating point values.
-.PP
-`\fB\-26\fR'
-`\fBcomplex\fR'.  A complex type consisting of two \s-1IEEE\s0 double-precision
-floating point values.
-.PP
-`\fB\-27\fR'
-`\fBinteger*1\fR', 8 bit signed integral type.
-.PP
-`\fB\-28\fR'
-`\fBinteger*2\fR', 16 bit signed integral type.
-.PP
-`\fB\-29\fR'
-`\fBinteger*4\fR', 32 bit signed integral type.
-.PP
-`\fB\-30\fR'
-`\fBwchar\fR'.  Wide character, 16 bits wide, unsigned (what format?
-Unicode?).
-.PP
-`\fB\-31\fR'
-`\fBlong long\fR', 64 bit signed integral type.
-.PP
-`\fB\-32\fR'
-`\fBunsigned long long\fR', 64 bit unsigned integral type.
-.PP
-`\fB\-33\fR'
-`\fBlogical*8\fR', 64 bit unsigned integral type.
-.PP
-`\fB\-34\fR'
-`\fBinteger*8\fR', 64 bit signed integral type.
-.PP
-\&\fB5.2 Miscellaneous Types\fR
-.PP
-`\fBb TYPE-INFORMATION ; \s-1BYTES\s0\fR'
-Pascal space type.  This is documented by \s-1IBM\s0; what does it mean?
-.PP
-This use of the `\fBb\fR' type descriptor can be distinguished from its
-use for builtin integral types (see \*(L"Builtin Type Descriptors\*(R")
-because the character following the type descriptor is always a
-digit, `\fB(\fR', or `\fB\-\fR'.
-.PP
-`\fBB TYPE-INFORMATION\fR'
-A volatile-qualified version of TYPE-INFORMATION.  This is a Sun
-extension.  References and stores to a variable with a
-volatile-qualified type must not be optimized or cached; they must
-occur as the user specifies them.
-.PP
-`\fBd TYPE-INFORMATION\fR'
-File of type TYPE-INFORMATION.  As far as I know this is only used
-by Pascal.
-.PP
-`\fBk TYPE-INFORMATION\fR'
-A const-qualified version of TYPE-INFORMATION.  This is a Sun
-extension.  A variable with a const-qualified type cannot be
-modified.
-.PP
-`\fBM TYPE-INFORMATION ; \s-1LENGTH\s0\fR'
-Multiple instance type.  The type seems to composed of \s-1LENGTH\s0
-repetitions of TYPE-INFORMATION, for example `\fBcharacter*3\fR' is
-represented by `\fBM\-2;3\fR', where `\fB\-2\fR' is a reference to a character
-type (see \*(L"Negative Type Numbers\*(R").  I'm not sure how this
-differs from an array.  This appears to be a Fortran feature.
-\&\s-1LENGTH\s0 is a bound, like those in range types; see *note
-Subranges::.
-.PP
-`\fBS TYPE-INFORMATION\fR'
-Pascal set type.  TYPE-INFORMATION must be a small type such as an
-enumeration or a subrange, and the type is a bitmask whose length
-is specified by the number of elements in TYPE-INFORMATION.
-.PP
-In \s-1CHILL,\s0 if it is a bitstring instead of a set, also use the `\fBS\fR'
-type attribute (see \*(L"String Field\*(R").
-.PP
-`\fB* TYPE-INFORMATION\fR'
-Pointer to TYPE-INFORMATION.
-.PP
-\&\fB5.3 Cross-References to Other Types\fR
-.PP
-A type can be used before it is defined; one common way to deal with
-that situation is just to use a type reference to a type which has not
-yet been defined.
-.PP
-Another way is with the `\fBx\fR' type descriptor, which is followed by
-`\fBs\fR' for a structure tag, `\fBu\fR' for a union tag, or `\fBe\fR' for a enumerator
-tag, followed by the name of the tag, followed by `\fB:\fR'.  If the name
-contains `\fB::\fR' between a `\fB<\fR' and `\fB>\fR' pair (for \*(C+ templates), such a
-`\fB::\fR' does not end the name\*(--only a single `\fB:\fR' ends the name; see *note
-Nested Symbols::.
-.PP
-For example, the following C declarations:
-.PP
-struct foo;
-struct foo *bar;
-.PP
-produce:
-.PP
-\&.stabs \*(L"bar:G16=*17=xsfoo:\*(R",32,0,0,0
-.PP
-Not all debuggers support the `\fBx\fR' type descriptor, so on some
-machines \s-1GCC\s0 does not use it.  I believe that for the above example it
-would just emit a reference to type 17 and never define it, but I
-haven't verified that.
-.PP
-Modula\-2 imported types, at least on \s-1AIX,\s0 use the `\fBi\fR' type
-descriptor, which is followed by the name of the module from which the
-type is imported, followed by `\fB:\fR', followed by the name of the type.
-There is then optionally a comma followed by type information for the
-type.  This differs from merely naming the type (see \*(L"Typedefs\*(R") in
-that it identifies the module; I don't understand whether the name of
-the type given here is always just the same as the name we are giving
-it, or whether this type descriptor is used with a nameless stab (*note
-String Field::), or what.  The symbol ends with `\fB;\fR'.
-.PP
-\&\fB5.4 Subrange Types\fR
-.PP
-The `\fBr\fR' type descriptor defines a type as a subrange of another type.
-It is followed by type information for the type of which it is a
-subrange, a semicolon, an integral lower bound, a semicolon, an
-integral upper bound, and a semicolon.  The \s-1AIX\s0 documentation does not
-specify the trailing semicolon, in an effort to specify array indexes
-more cleanly, but a subrange which is not an array index has always
-included a trailing semicolon (see \*(L"Arrays\*(R").
-.PP
-Instead of an integer, either bound can be one of the following:
-.PP
-`\fBA \s-1OFFSET\s0\fR'
-The bound is passed by reference on the stack at offset \s-1OFFSET\s0
-from the argument list.  see \*(L"Parameters\*(R", for more information
-on such offsets.
-.PP
-`\fBT \s-1OFFSET\s0\fR'
-The bound is passed by value on the stack at offset \s-1OFFSET\s0 from
-the argument list.
-.PP
-`\fBa REGISTER-NUMBER\fR'
-The bound is passed by reference in register number
-REGISTER-NUMBER.
-.PP
-`\fBt REGISTER-NUMBER\fR'
-The bound is passed by value in register number REGISTER-NUMBER.
-.PP
-`\fBJ\fR'
-There is no bound.
-.PP
-Subranges are also used for builtin types; see *note Traditional
-Builtin Types::.
-.PP
-\&\fB5.5 Array Types\fR
-.PP
-Arrays use the `\fBa\fR' type descriptor.  Following the type descriptor is
-the type of the index and the type of the array elements.  If the index
-type is a range type, it ends in a semicolon; otherwise (for example,
-if it is a type reference), there does not appear to be any way to tell
-where the types are separated.  In an effort to clean up this mess, \s-1IBM\s0
-documents the two types as being separated by a semicolon, and a range
-type as not ending in a semicolon (but this is not right for range
-types which are not array indexes, see \*(L"Subranges\*(R").  I think
-probably the best solution is to specify that a semicolon ends a range
-type, and that the index type and element type of an array are
-separated by a semicolon, but that if the index type is a range type,
-the extra semicolon can be omitted.  \s-1GDB \s0(at least through version 4.9)
-doesn't support any kind of index type other than a range anyway; I'm
-not sure about dbx.
-.PP
-It is well established, and widely used, that the type of the index,
-unlike most types found in the stabs, is merely a type definition, not
-type information (see \*(L"String Field\*(R") (that is, it need not start with
-`\fBTYPE\-NUMBER=\fR' if it is defining a new type).  According to a comment
-in \s-1GDB,\s0 this is also true of the type of the array elements; it gives
-`\fBar1;1;10;ar1;1;10;4\fR' as a legitimate way to express a two dimensional
-array.  According to \s-1AIX\s0 documentation, the element type must be type
-information.  \s-1GDB\s0 accepts either.
-.PP
-The type of the index is often a range type, expressed as the type
-descriptor `\fBr\fR' and some parameters.  It defines the size of the array.
-In the example below, the range `\fBr1;0;2;\fR' defines an index type which
-is a subrange of type 1 (integer), with a lower bound of 0 and an upper
-bound of 2.  This defines the valid range of subscripts of a
-three-element C array.
-.PP
-For example, the definition:
-.PP
-char char_vec[3] = {'a','b','c'};
-.PP
-produces the output:
-.PP
-\&.stabs \*(L"char_vec:G19=ar1;0;2;2\*(R",32,0,0,0
-\&.global _char_vec
-\&.align 4
-_char_vec:
-\&.byte 97
-\&.byte 98
-\&.byte 99
-.PP
-If an array is \*(L"packed\*(R", the elements are spaced more closely than
-normal, saving memory at the expense of speed.  For example, an array
-of 3\-byte objects might, if unpacked, have each element aligned on a
-4\-byte boundary, but if packed, have no padding.  One way to specify
-that something is packed is with type attributes (*note String
-Field::).  In the case of arrays, another is to use the `\fBP\fR' type
-descriptor instead of `\fBa\fR'.  Other than specifying a packed array, `\fBP\fR'
-is identical to `\fBa\fR'.
-.PP
-An open array is represented by the `\fBA\fR' type descriptor followed by
-type information specifying the type of the array elements.
-.PP
-An N\-dimensional dynamic array is represented by
-.PP
-D \s-1DIMENSIONS \s0; TYPE-INFORMATION
-.PP
-\&\s-1DIMENSIONS\s0 is the number of dimensions; TYPE-INFORMATION specifies
-the type of the array elements.
-.PP
-A subarray of an N\-dimensional array is represented by
-.PP
-E \s-1DIMENSIONS \s0; TYPE-INFORMATION
-.PP
-\&\s-1DIMENSIONS\s0 is the number of dimensions; TYPE-INFORMATION specifies
-the type of the array elements.
-.PP
-\&\fB5.6 Strings\fR
-.PP
-Some languages, like C or the original Pascal, do not have string types,
-they just have related things like arrays of characters.  But most
-Pascals and various other languages have string types, which are
-indicated as follows:
-.PP
-`\fBn TYPE-INFORMATION ; \s-1BYTES\s0\fR'
-\&\s-1BYTES\s0 is the maximum length.  I'm not sure what TYPE-INFORMATION
-is; I suspect that it means that this is a string of
-TYPE-INFORMATION (thus allowing a string of integers, a string of
-wide characters, etc., as well as a string of characters).  Not
-sure what the format of this type is.  This is an \s-1AIX\s0 feature.
-.PP
-`\fBz TYPE-INFORMATION ; \s-1BYTES\s0\fR'
-Just like `\fBn\fR' except that this is a gstring, not an ordinary
-string.  I don't know the difference.
-.PP
-`\fBN\fR'
-Pascal Stringptr.  What is this?  This is an \s-1AIX\s0 feature.
-.PP
-Languages, such as \s-1CHILL\s0 which have a string type which is basically
-just an array of characters use the `\fBS\fR' type attribute (*note String
-Field::).
-.PP
-\&\fB5.7 Enumerations\fR
-.PP
-Enumerations are defined with the `\fBe\fR' type descriptor.
-.PP
-The source line below declares an enumeration type at file scope.
-The type definition is located after the `\fBN_RBRAC\fR' that marks the end of
-the previous procedure's block scope, and before the `\fBN_FUN\fR' that marks
-the beginning of the next procedure's block scope.  Therefore it does
-not describe a block local symbol, but a file local one.
-.PP
-The source line:
-.PP
-enum e_places {first,second=3,last};
-.PP
-generates the following stab:
-.PP
-\&.stabs \*(L"e_places:T22=efirst:0,second:3,last:4,;\*(R",128,0,0,0
-.PP
-The symbol descriptor (`\fBT\fR') says that the stab describes a
-structure, enumeration, or union tag.  The type descriptor `\fBe\fR',
-following the `\fB22=\fR' of the type definition narrows it down to an
-enumeration type.  Following the `\fBe\fR' is a list of the elements of the
-enumeration.  The format is `\fB\s-1NAME:VALUE,\s0\fR'.  The list of elements ends
-with `\fB;\fR'.  The fact that \s-1VALUE\s0 is specified as an integer can cause
-problems if the value is large.  \s-1GCC 2.5.2\s0 tries to output it in octal
-in that case with a leading zero, which is probably a good thing,
-although \s-1GDB 4.11\s0 supports octal only in cases where decimal is
-perfectly good.  Negative decimal values are supported by both \s-1GDB\s0 and
-dbx.
-.PP
-There is no standard way to specify the size of an enumeration type;
-it is determined by the architecture (normally all enumerations types
-are 32 bits).  Type attributes can be used to specify an enumeration
-type of another size for debuggers which support them; see *note String
-Field::.
-.PP
-Enumeration types are unusual in that they define symbols for the
-enumeration values (`\fBfirst\fR', `\fBsecond\fR', and `\fBthird\fR' in the above
-example), and even though these symbols are visible in the file as a
-whole (rather than being in a more local namespace like structure
-member names), they are defined in the type definition for the
-enumeration type rather than each having their own symbol.  In order to
-be fast, \s-1GDB\s0 will only get symbols from such types (in its initial scan
-of the stabs) if the type is the first thing defined after a `\fBT\fR' or `\fBt\fR'
-symbol descriptor (the above example fulfills this requirement).  If
-the type does not have a name, the compiler should emit it in a
-nameless stab (see \*(L"String Field\*(R"); \s-1GCC\s0 does this.
-.PP
-\&\fB5.8 Structures\fR
-.PP
-The encoding of structures in stabs can be shown with an example.
-.PP
-The following source code declares a structure tag and defines an
-instance of the structure in global scope. Then a `\fBtypedef\fR' equates the
-structure tag with a new type.  Separate stabs are generated for the
-structure tag, the structure `\fBtypedef\fR', and the structure instance.  The
-stabs for the tag and the `\fBtypedef\fR' are emitted when the definitions are
-encountered.  Since the structure elements are not initialized, the
-stab and code for the structure variable itself is located at the end
-of the program in the bss section.
-.PP
-struct s_tag {
-int   s_int;
-float s_float;
-char  s_char_vec[8];
-struct s_tag* s_next;
-} g_an_s;
-.PP
-typedef struct s_tag s_typedef;
-.PP
-The structure tag has an `\fBN_LSYM\fR' stab type because, like the
-enumeration, the symbol has file scope.  Like the enumeration, the
-symbol descriptor is `\fBT\fR', for enumeration, structure, or tag type.  The
-type descriptor `\fBs\fR' following the `\fB16=\fR' of the type definition narrows
-the symbol type to structure.
-.PP
-Following the `\fBs\fR' type descriptor is the number of bytes the
-structure occupies, followed by a description of each structure element.
-The structure element descriptions are of the form `\s-1NAME:TYPE, BIT
-OFFSET FROM THE START OF THE STRUCT, NUMBER OF BITS IN THE ELEMENT\s0'.
-.PP
-# 128 is N_LSYM
-\&.stabs \*(L"s_tag:T16=s20s_int:1,0,32;s_float:12,32,32;
-s_char_vec:17=ar1;0;7;2,64,64;s_next:18=*16,128,32;;\*(R",128,0,0,0
-.PP
-In this example, the first two structure elements are previously
-defined types.  For these, the type following the `\fB\s-1NAME:\s0\fR' part of the
-element description is a simple type reference.  The other two structure
-elements are new types.  In this case there is a type definition
-embedded after the `\fB\s-1NAME:\s0\fR'.  The type definition for the array element
-looks just like a type definition for a stand-alone array.  The
-`\fBs_next\fR' field is a pointer to the same kind of structure that the
-field is an element of.  So the definition of structure type 16
-contains a type definition for an element which is a pointer to type 16.
-.PP
-If a field is a static member (this is a \*(C+ feature in which a
-single variable appears to be a field of every structure of a given
-type) it still starts out with the field name, a colon, and the type,
-but then instead of a comma, bit position, comma, and bit size, there
-is a colon followed by the name of the variable which each such field
-refers to.
-.PP
-If the structure has methods (a \*(C+ feature), they follow the
-non-method fields; see see \*(L"Cplusplus\*(R".
-.PP
-\&\fB5.9 Giving a Type a Name\fR
-.PP
-To give a type a name, use the `\fBt\fR' symbol descriptor.  The type is
-specified by the type information (see \*(L"String Field\*(R") for the stab.
-For example,
-.PP
-\&.stabs \*(L"s_typedef:t16\*(R",128,0,0,0     # 128 is N_LSYM
-.PP
-specifies that `\fBs_typedef\fR' refers to type number 16.  Such stabs
-have symbol type `\fBN_LSYM\fR' (or `\fBC_DECL\fR' for \s-1XCOFF\s0).  (The Sun
-documentation mentions using `\fBN_GSYM\fR' in some cases).
-.PP
-If you are specifying the tag name for a structure, union, or
-enumeration, use the `\fBT\fR' symbol descriptor instead.  I believe C is the
-only language with this feature.
-.PP
-If the type is an opaque type (I believe this is a Modula\-2 feature),
-\&\s-1AIX\s0 provides a type descriptor to specify it.  The type descriptor is
-`\fBo\fR' and is followed by a name.  I don't know what the name means\*(--is it
-always the same as the name of the type, or is this type descriptor
-used with a nameless stab (see \*(L"String Field\*(R")?  There optionally
-follows a comma followed by type information which defines the type of
-this type.  If omitted, a semicolon is used in place of the comma and
-the type information, and the type is much like a generic pointer
-type\*(--it has a known size but little else about it is specified.
-.PP
-\&\fB5.10 Unions\fR
-.PP
-union u_tag {
-int  u_int;
-float u_float;
-char* u_char;
-} an_u;
-.PP
-This code generates a stab for a union tag and a stab for a union
-variable.  Both use the `\fBN_LSYM\fR' stab type.  If a union variable is
-scoped locally to the procedure in which it is defined, its stab is
-located immediately preceding the `\fBN_LBRAC\fR' for the procedure's block
-start.
-.PP
-The stab for the union tag, however, is located preceding the code
-for the procedure in which it is defined.  The stab type is `\fBN_LSYM\fR'.
-This would seem to imply that the union type is file scope, like the
-struct type `\fBs_tag\fR'.  This is not true.  The contents and position of
-the stab for `\fBu_type\fR' do not convey any information about its procedure
-local scope.
-.PP
-# 128 is N_LSYM
-\&.stabs \*(L"u_tag:T23=u4u_int:1,0,32;u_float:12,0,32;u_char:21,0,32;;\*(R",
-128,0,0,0
-.PP
-The symbol descriptor `\fBT\fR', following the `\fBname:\fR' means that the stab
-describes an enumeration, structure, or union tag.  The type descriptor
-`\fBu\fR', following the `\fB23=\fR' of the type definition, narrows it down to a
-union type definition.  Following the `\fBu\fR' is the number of bytes in the
-union.  After that is a list of union element descriptions.  Their
-format is `\s-1NAME:TYPE, BIT OFFSET INTO THE UNION, NUMBER OF BYTES FOR
-THE ELEMENT\s0;'.
-.PP
-The stab for the union variable is:
-.PP
-\&.stabs \*(L"an_u:23\*(R",128,0,0,\-20     # 128 is N_LSYM
-.PP
-`\fB\-20\fR' specifies where the variable is stored (*note Stack
-Variables::).
-.PP
-\&\fB5.11 Function Types\fR
-.PP
-Various types can be defined for function variables.  These types are
-not used in defining functions (see \*(L"Procedures\*(R"); they are used for
-things like pointers to functions.
-.PP
-The simple, traditional, type is type descriptor `\fBf\fR' is followed by
-type information for the return type of the function, followed by a
-semicolon.
-.PP
-This does not deal with functions for which the number and types of
-the parameters are part of the type, as in Modula\-2 or \s-1ANSI C.  AIX\s0
-provides extensions to specify these, using the `\fBf\fR', `\fBF\fR', `\fBp\fR', and `\fBR\fR'
-type descriptors.
-.PP
-First comes the type descriptor.  If it is `\fBf\fR' or `\fBF\fR', this type
-involves a function rather than a procedure, and the type information
-for the return type of the function follows, followed by a comma.  Then
-comes the number of parameters to the function and a semicolon.  Then,
-for each parameter, there is the name of the parameter followed by a
-colon (this is only present for type descriptors `\fBR\fR' and `\fBF\fR' which
-represent Pascal function or procedure parameters), type information
-for the parameter, a comma, 0 if passed by reference or 1 if passed by
-value, and a semicolon.  The type definition ends with a semicolon.
-.PP
-For example, this variable definition:
-.PP
-int (*g_pf)();
-.PP
-generates the following code:
-.PP
-\&.stabs \*(L"g_pf:G24=*25=f1\*(R",32,0,0,0
-\&.common _g_pf,4,\*(L"bss\*(R"
-.PP
-The variable defines a new type, 24, which is a pointer to another
-new type, 25, which is a function returning `\fBint\fR'.
-.SS "6 Representation of #define and #undef"
-.IX Subsection "6 Representation of #define and #undef"
-This section describes the stabs support for macro define and undefine
-information, supported on some systems.  (e.g., with `\fB\-g3\fR' `\fB\-gstabs\fR'
-when using \s-1GCC\s0).
-.PP
-A `\fB#define MACRO-NAME MACRO-BODY\fR' is represented with an
-`\fBN_MAC_DEFINE\fR' stab with a string field of `\fBMACRO-NAME MACRO-BODY\fR'.
-.PP
-An `\fB#undef MACRO-NAME\fR' is represented with an `\fBN_MAC_UNDEF\fR' stabs
-with a string field of simply `\fBMACRO-NAME\fR'.
-.PP
-For both `\fBN_MAC_DEFINE\fR' and `\fBN_MAC_UNDEF\fR', the desc field is the
-line number within the file where the corresponding `\fB#define\fR' or
-`\fB#undef\fR' occurred.
-.PP
-For example, the following C code:
-.PP
-#define \s-1NONE   42\s0
-#define \s-1TWO\s0(a, b)      (a + (a) + 2 * b)
-#define \s-1ONE\s0(c) (c + 19)
-.PP
-main(int argc, char *argv[])
-{
-func(\s-1NONE, TWO\s0(10, 11));
-func(\s-1NONE, ONE\s0(23));
-.PP
-#undef \s-1ONE\s0
-#define \s-1ONE\s0(c) (c + 23)
-.PP
-func(\s-1NONE, ONE\s0(\-23));
-.PP
-return (0);
-}
-.PP
-int global;
-.PP
-func(int arg1, int arg2)
-{
-global = arg1 + arg2;
-}
-.PP
-produces the following stabs (as well as many others):
-.PP
-\&.stabs \*(L"\s-1NONE 42\*(R",54,0,1,0
-\&\s0.stabs \*(L"\s-1TWO\s0(a,b) (a + (a) + 2 * b)\*(R",54,0,2,0
-\&.stabs \*(L"\s-1ONE\s0(c) (c + 19)\*(R",54,0,3,0
-\&.stabs \*(L"\s-1ONE\*(R",58,0,10,0
-\&\s0.stabs \*(L"\s-1ONE\s0(c) (c + 23)\*(R",54,0,11,0
-.PP
-\&\s-1NOTE:\s0 In the above example, `\fB54\fR' is `\fBN_MAC_DEFINE\fR' and `\fB58\fR' is
-`\fBN_MAC_UNDEF\fR'.
-.SS "7 Symbol Information in Symbol Tables"
-.IX Subsection "7 Symbol Information in Symbol Tables"
-This chapter describes the format of symbol table entries and how stab
-assembler directives map to them.  It also describes the
-transformations that the assembler and linker make on data from stabs.
-.PP
-* Menu:
-.PP
-See also \*(L"Symbol Table Format\*(R"
-.PP
-See also \*(L"Transformations On Symbol Tables\*(R"
-.PP
-\&\fB7.1 Symbol Table Format\fR
-.PP
-Each time the assembler encounters a stab directive, it puts each field
-of the stab into a corresponding field in a symbol table entry of its
-output file.  If the stab contains a string field, the symbol table
-entry for that stab points to a string table entry containing the
-string data from the stab.  Assembler labels become relocatable
-addresses.  Symbol table entries in a.out have the format:
-.PP
-struct internal_nlist {
-unsigned long n_strx;         /* index into string table of name */
-unsigned char n_type;         /* type of symbol */
-unsigned char n_other;        /* misc info (usually empty) */
-unsigned short n_desc;        /* description field */
-bfd_vma n_value;              /* value of symbol */
-};
-.PP
-If the stab has a string, the `\fBn_strx\fR' field holds the offset in
-bytes of the string within the string table.  The string is terminated
-by a \s-1NUL\s0 character.  If the stab lacks a string (for example, it was
-produced by a `\fB.stabn\fR' or `\fB.stabd\fR' directive), the `\fBn_strx\fR' field is
-zero.
-.PP
-Symbol table entries with `\fBn_type\fR' field values greater than 0x1f
-originated as stabs generated by the compiler (with one random
-exception).  The other entries were placed in the symbol table of the
-executable by the assembler or the linker.
-.PP
-\&\fB7.2 Transformations on Symbol Tables\fR
-.PP
-The linker concatenates object files and does fixups of externally
-defined symbols.
-.PP
-You can see the transformations made on stab data by the assembler
-and linker by examining the symbol table after each pass of the build.
-To do this, use `\fBnm \-ap\fR', which dumps the symbol table, including
-debugging information, unsorted.  For stab entries the columns are:
-\&\s-1VALUE, OTHER, DESC, TYPE, STRING. \s0 For assembler and linker symbols,
-the columns are: \s-1VALUE, TYPE, STRING.\s0
-.PP
-The low 5 bits of the stab type tell the linker how to relocate the
-value of the stab.  Thus for stab types like `\fBN_RSYM\fR' and `\fBN_LSYM\fR',
-where the value is an offset or a register number, the low 5 bits are
-`\fBN_ABS\fR', which tells the linker not to relocate the value.
-.PP
-Where the value of a stab contains an assembly language label, it is
-transformed by each build step.  The assembler turns it into a
-relocatable address and the linker turns it into an absolute address.
-.PP
-* Menu:
-.PP
-See also \*(L"Transformations On Static Variables\*(R"
-.PP
-See also \*(L"Transformations On Global Variables\*(R"
-.PP
-For some object file formats,: see \*(L"Stab Section Transformations\*(R"
-.PP
-things are a bit different.
-.PP
-\&\fB7.2.1 Transformations on Static Variables\fR
-.PP
-This source line defines a static variable at file scope:
-.PP
-static int s_g_repeat
-.PP
-The following stab describes the symbol:
-.PP
-\&.stabs \*(L"s_g_repeat:S1\*(R",38,0,0,_s_g_repeat
-.PP
-The assembler transforms the stab into this symbol table entry in the
-`\fB.o\fR' file.  The location is expressed as a data segment offset.
-.PP
-00000084 \- 00 0000 \s-1STSYM\s0 s_g_repeat:S1
-.PP
-In the symbol table entry from the executable, the linker has made the
-relocatable address absolute.
-.PP
-0000e00c \- 00 0000 \s-1STSYM\s0 s_g_repeat:S1
-.PP
-\&\fB7.2.2 Transformations on Global Variables\fR
-.PP
-Stabs for global variables do not contain location information. In this
-case, the debugger finds location information in the assembler or
-linker symbol table entry describing the variable.  The source line:
-.PP
-char g_foo = 'c';
-.PP
-generates the stab:
-.PP
-\&.stabs \*(L"g_foo:G2\*(R",32,0,0,0
-.PP
-The variable is represented by two symbol table entries in the object
-file (see below).  The first one originated as a stab.  The second one
-is an external symbol.  The upper case `\fBD\fR' signifies that the `\fBn_type\fR'
-field of the symbol table contains 7, `\fBN_DATA\fR' with local linkage.  The
-stab's value is zero since the value is not used for `\fBN_GSYM\fR' stabs.
-The value of the linker symbol is the relocatable address corresponding
-to the variable.
-.PP
-00000000 \- 00 0000  \s-1GSYM\s0 g_foo:G2
-00000080 D _g_foo
-.PP
-These entries as transformed by the linker.  The linker symbol table
-entry now holds an absolute address:
-.PP
-00000000 \- 00 0000  \s-1GSYM\s0 g_foo:G2
-\&...
-0000e008 D _g_foo
-.PP
-\&\fB7.2.3 Transformations of Stabs in separate sections\fR
-.PP
-For object file formats using stabs in separate sections (*note Stab
-Sections::), use `\fBobjdump \-\-stabs\fR' instead of `\fBnm\fR' to show the stabs in
-an object or executable file.  `\fBobjdump\fR' is a \s-1GNU\s0 utility; Sun does not
-provide any equivalent.
-.PP
-The following example is for a stab whose value is an address is
-relative to the compilation unit (see \*(L"\s-1ELF\s0 Linker Relocation\*(R").  For
-example, if the source line
-.PP
-static int ld = 5;
-.PP
-appears within a function, then the assembly language output from the
-compiler contains:
-.PP
-\&.Ddata.data:
-\&...
-\&.stabs \*(L"ld:V(0,3)\*(R",0x26,0,4,.L18\-Ddata.data    # 0x26 is N_STSYM
-\&...
-\&.L18:
-\&.align 4
-\&.word 0x5
-.PP
-Because the value is formed by subtracting one symbol from another,
-the value is absolute, not relocatable, and so the object file contains
-.PP
-Symnum n_type n_othr n_desc n_value  n_strx String
-31     \s-1STSYM  0      4      00000004 680   \s0 ld:V(0,3)
-.PP
-without any relocations, and the executable file also contains
-.PP
-Symnum n_type n_othr n_desc n_value  n_strx String
-31     \s-1STSYM  0      4      00000004 680   \s0 ld:V(0,3)
-.SS "8 \s-1GNU \*(C+\s0 Stabs"
-.IX Subsection "8 GNU Stabs"
-* Menu:
-.PP
-\&\*(C+ class names are both tags and typedefs.: see \*(L"Class Names\*(R"
-.PP
-\&\*(C+ symbol names can be within other types.: see \*(L"Nested Symbols\*(R"
-.PP
-See also \*(L"Basic Cplusplus Types\*(R"
-.PP
-See also \*(L"Simple Classes\*(R"
-.PP
-See also \*(L"Class Instance\*(R"
-.PP
-Method definition: see \*(L"Methods\*(R"
-.PP
-The `\fB#\fR' type descriptor: see \*(L"Method Type Descriptor\*(R"
-.PP
-The `\fB@\fR' type descriptor: see \*(L"Member Type Descriptor\*(R"
-.PP
-See also \*(L"Protections\*(R"
-.PP
-See also \*(L"Method Modifiers\*(R"
-.PP
-See also \*(L"Virtual Methods\*(R"
-.PP
-See also \*(L"Inheritance\*(R"
-.PP
-See also \*(L"Virtual Base Classes\*(R"
-.PP
-See also \*(L"Static Members\*(R"
-.PP
-\&\fB8.1 \*(C+ Class Names\fR
-.PP
-In \*(C+, a class name which is declared with `\fBclass\fR', `\fBstruct\fR', or
-`\fBunion\fR', is not only a tag, as in C, but also a type name.  Thus there
-should be stabs with both `\fBt\fR' and `\fBT\fR' symbol descriptors (*note
-Typedefs::).
-.PP
-To save space, there is a special abbreviation for this case.  If the
-`\fBT\fR' symbol descriptor is followed by `\fBt\fR', then the stab defines both a
-type name and a tag.
-.PP
-For example, the \*(C+ code
-.PP
-struct foo {int x;};
-.PP
-can be represented as either
-.PP
-\&.stabs \*(L"foo:T19=s4x:1,0,32;;\*(R",128,0,0,0       # 128 is N_LSYM
-\&.stabs \*(L"foo:t19\*(R",128,0,0,0
-.PP
-or
-.PP
-\&.stabs \*(L"foo:Tt19=s4x:1,0,32;;\*(R",128,0,0,0
-.PP
-\&\fB8.2 Defining a Symbol Within Another Type\fR
-.PP
-In \*(C+, a symbol (such as a type name) can be defined within another
-type.
-.PP
-In stabs, this is sometimes represented by making the name of a
-symbol which contains `\fB::\fR'.  Such a pair of colons does not end the name
-of the symbol, the way a single colon would (see \*(L"String Field\*(R").  I'm
-not sure how consistently used or well thought out this mechanism is.
-So that a pair of colons in this position always has this meaning, `\fB:\fR'
-cannot be used as a symbol descriptor.
-.PP
-For example, if the string for a stab is `\fBfoo::bar::baz:t5=*6\fR', then
-`\fBfoo::bar::baz\fR' is the name of the symbol, `\fBt\fR' is the symbol
-descriptor, and `\fB5=*6\fR' is the type information.
-.PP
-\&\fB8.3 Basic Types For \*(C+\fR
-.PP
-<< the examples that follow are based on a01.C >>
-.PP
-\&\*(C+ adds two more builtin types to the set defined for C.  These are
-the unknown type and the vtable record type.  The unknown type, type
-16, is defined in terms of itself like the void type.
-.PP
-The vtable record type, type 17, is defined as a structure type and
-then as a structure tag.  The structure has four fields: delta, index,
-pfn, and delta2.  pfn is the function pointer.
-.PP
-<< In boilerplate \f(CW$vtbl_ptr_type\fR, what are the fields delta, index,
-and delta2 used for? >>
-.PP
-This basic type is present in all \*(C+ programs even if there are no
-virtual methods defined.
-.PP
-\&.stabs \*(L"struct_name:sym_desc(type)type_def(17)=type_desc(struct)\fIstruct_bytes\fR\|(8)
-elem_name(delta):type_ref(short int),\fIbit_offset\fR\|(0),field_bits(16);
-elem_name(index):type_ref(short int),bit_offset(16),field_bits(16);
-elem_name(pfn):type_def(18)=type_desc(ptr to)type_ref(void),
-bit_offset(32),field_bits(32);
-elem_name(delta2):type_def(short int);bit_offset(32),field_bits(16);;\*(R"
-N_LSYM, \s-1NIL, NIL\s0
-.PP
-\&.stabs \*(L"$vtbl_ptr_type:t17=s8
-delta:6,0,16;index:6,16,16;pfn:18=*15,32,32;delta2:6,32,16;;\*(R"
-,128,0,0,0
-.PP
-\&.stabs \*(L"name:sym_dec(struct tag)type_ref($vtbl_ptr_type)\*(R",N_LSYM,NIL,NIL,NIL
-.PP
-\&.stabs \*(L"$vtbl_ptr_type:T17\*(R",128,0,0,0
-.PP
-\&\fB8.4 Simple Class Definition\fR
-.PP
-The stabs describing \*(C+ language features are an extension of the
-stabs describing C.  Stabs representing \*(C+ class types elaborate
-extensively on the stab format used to describe structure types in C.
-Stabs representing class type variables look just like stabs
-representing C language variables.
-.PP
-Consider the following very simple class definition.
-.PP
-class baseA {
-public:
-int Adat;
-int Ameth(int in, char other);
-};
-.PP
-The class `\fBbaseA\fR' is represented by two stabs.  The first stab
-describes the class as a structure type.  The second stab describes a
-structure tag of the class type.  Both stabs are of stab type `\fBN_LSYM\fR'.
-Since the stab is not located between an `\fBN_FUN\fR' and an `\fBN_LBRAC\fR' stab
-this indicates that the class is defined at file scope.  If it were,
-then the `\fBN_LSYM\fR' would signify a local variable.
-.PP
-A stab describing a \*(C+ class type is similar in format to a stab
-describing a C struct, with each class member shown as a field in the
-structure.  The part of the struct format describing fields is expanded
-to include extra information relevant to \*(C+ class members.  In
-addition, if the class has multiple base classes or virtual functions
-the struct format outside of the field parts is also augmented.
-.PP
-In this simple example the field part of the \*(C+ class stab
-representing member data looks just like the field part of a C struct
-stab.  The section on protections describes how its format is sometimes
-extended for member data.
-.PP
-The field part of a \*(C+ class stab representing a member function
-differs substantially from the field part of a C struct stab.  It still
-begins with `\fBname:\fR' but then goes on to define a new type number for
-the member function, describe its return type, its argument types, its
-protection level, any qualifiers applied to the method definition, and
-whether the method is virtual or not.  If the method is virtual then
-the method description goes on to give the vtable index of the method,
-and the type number of the first base class defining the method.
-.PP
-When the field name is a method name it is followed by two colons
-rather than one.  This is followed by a new type definition for the
-method.  This is a number followed by an equal sign and the type of the
-method.  Normally this will be a type declared using the `\fB#\fR' type
-descriptor; see see \*(L"Method Type Descriptor\*(R"; static member functions
-are declared using the `\fBf\fR' type descriptor instead; see *note Function
-Types::.
-.PP
-The format of an overloaded operator method name differs from that of
-other methods.  It is `\fBop$::OPERATOR\-NAME.\fR' where OPERATOR-NAME is the
-operator name such as `\fB+\fR' or `\fB+=\fR'.  The name ends with a period, and
-any characters except the period can occur in the OPERATOR-NAME string.
-.PP
-The next part of the method description represents the arguments to
-the method, preceded by a colon and ending with a semi-colon.  The
-types of the arguments are expressed in the same way argument types are
-expressed in \*(C+ name mangling.  In this example an `\fBint\fR' and a `\fBchar\fR'
-map to `\fBic\fR'.
-.PP
-This is followed by a number, a letter, and an asterisk or period,
-followed by another semicolon.  The number indicates the protections
-that apply to the member function.  Here the 2 means public.  The
-letter encodes any qualifier applied to the method definition.  In this
-case, `\fBA\fR' means that it is a normal function definition.  The dot shows
-that the method is not virtual.  The sections that follow elaborate
-further on these fields and describe the additional information present
-for virtual methods.
-.PP
-\&.stabs "class_name:sym_desc(type)type_def(20)=type_desc(struct)\fIstruct_bytes\fR\|(4)
-field_name(Adat):type(int),\fIbit_offset\fR\|(0),field_bits(32);
-.PP
-method_name(Ameth)::type_def(21)=type_desc(method)return_type(int);
-:arg_types(int char);
-protection(public)qualifier(normal)virtual(no);;"
-N_LSYM,NIL,NIL,NIL
-.PP
-\&.stabs \*(L"baseA:t20=s4Adat:1,0,32;Ameth::21=##1;:ic;2A.;;\*(R",128,0,0,0
-.PP
-\&.stabs \*(L"class_name:sym_desc(struct tag)\*(R",N_LSYM,NIL,NIL,NIL
-.PP
-\&.stabs \*(L"baseA:T20\*(R",128,0,0,0
-.PP
-\&\fB8.5 Class Instance\fR
-.PP
-As shown above, describing even a simple \*(C+ class definition is
-accomplished by massively extending the stab format used in C to
-describe structure types.  However, once the class is defined, C stabs
-with no modifications can be used to describe class instances.  The
-following source:
-.PP
-main () {
-baseA AbaseA;
-}
-.PP
-yields the following stab describing the class instance.  It looks no
-different from a standard C stab describing a local variable.
-.PP
-\&.stabs \*(L"name:type_ref(baseA)\*(R", N_LSYM, \s-1NIL, NIL,\s0 frame_ptr_offset
-.PP
-\&.stabs \*(L"AbaseA:20\*(R",128,0,0,\-20
-.PP
-\&\fB8.6 Method Definition\fR
-.PP
-The class definition shown above declares Ameth.  The \*(C+ source below
-defines Ameth:
-.PP
-int
-baseA::Ameth(int in, char other)
-{
-return in;
-};
-.PP
-This method definition yields three stabs following the code of the
-method.  One stab describes the method itself and following two describe
-its parameters.  Although there is only one formal argument all methods
-have an implicit argument which is the `\fBthis\fR' pointer.  The `\fBthis\fR'
-pointer is a pointer to the object on which the method was called.  Note
-that the method name is mangled to encode the class name and argument
-types.  Name mangling is described in the \s-1ARM \s0(`The Annotated \*(C+
-Reference Manual', by Ellis and Stroustrup, \s-1ISBN 0\-201\-51459\-1\s0);
-`\fBgpcompare.texi\fR' in Cygnus \s-1GCC\s0 distributions describes the differences
-between \s-1GNU\s0 mangling and \s-1ARM\s0 mangling.
-.PP
-\&.stabs \*(L"name:symbol_descriptor(global function)return_type(int)\*(R",
-N_FUN, \s-1NIL, NIL,\s0 code_addr_of_method_start
-.PP
-\&.stabs \*(L"Ameth_\|_5baseAic:F1\*(R",36,0,0,_Ameth_\|_5baseAic
-.PP
-Here is the stab for the `\fBthis\fR' pointer implicit argument.  The name
-of the `\fBthis\fR' pointer is always `\fBthis\fR'.  Type 19, the `\fBthis\fR' pointer is
-defined as a pointer to type 20, `\fBbaseA\fR', but a stab defining `\fBbaseA\fR'
-has not yet been emitted.  Since the compiler knows it will be emitted
-shortly, here it just outputs a cross reference to the undefined
-symbol, by prefixing the symbol name with `\fBxs\fR'.
-.PP
-\&.stabs \*(L"name:sym_desc(register param)type_def(19)=
-type_desc(ptr to)type_ref(baseA)=
-type_desc(cross\-reference to)baseA:\*(R",N_RSYM,NIL,NIL,register_number
-.PP
-\&.stabs \*(L"this:P19=*20=xsbaseA:\*(R",64,0,0,8
-.PP
-The stab for the explicit integer argument looks just like a
-parameter to a C function.  The last field of the stab is the offset
-from the argument pointer, which in most systems is the same as the
-frame pointer.
-.PP
-\&.stabs \*(L"name:sym_desc(value parameter)type_ref(int)\*(R",
-N_PSYM,NIL,NIL,offset_from_arg_ptr
-.PP
-\&.stabs \*(L"in:p1\*(R",160,0,0,72
-.PP
-<< The examples that follow are based on A1.C >>
-.PP
-\&\fB8.7 The `#' Type Descriptor\fR
-.PP
-This is used to describe a class method.  This is a function which takes
-an extra argument as its first argument, for the `\fBthis\fR' pointer.
-.PP
-If the `\fB#\fR' is immediately followed by another `\fB#\fR', the second one
-will be followed by the return type and a semicolon.  The class and
-argument types are not specified, and must be determined by demangling
-the name of the method if it is available.
-.PP
-Otherwise, the single `\fB#\fR' is followed by the class type, a comma,
-the return type, a comma, and zero or more parameter types separated by
-commas.  The list of arguments is terminated by a semicolon.  In the
-debugging output generated by gcc, a final argument type of `\fBvoid\fR'
-indicates a method which does not take a variable number of arguments.
-If the final argument type of `\fBvoid\fR' does not appear, the method was
-declared with an ellipsis.
-.PP
-Note that although such a type will normally be used to describe
-fields in structures, unions, or classes, for at least some versions of
-the compiler it can also be used in other contexts.
-.PP
-\&\fB8.8 The `@' Type Descriptor\fR
-.PP
-The `\fB@\fR' type descriptor is used for a pointer-to-non-static-member-data
-type.  It is followed by type information for the class (or union), a
-comma, and type information for the member data.
-.PP
-The following \*(C+ source:
-.PP
-typedef int A::*int_in_a;
-.PP
-generates the following stab:
-.PP
-\&.stabs \*(L"int_in_a:t20=21=@19,1\*(R",128,0,0,0
-.PP
-Note that there is a conflict between this and type attributes
-(see \*(L"String Field\*(R"); both use type descriptor `\fB@\fR'.  Fortunately, the
-`\fB@\fR' type descriptor used in this \*(C+ sense always will be followed by a
-digit, `\fB(\fR', or `\fB\-\fR', and type attributes never start with those things.
-.PP
-\&\fB8.9 Protections\fR
-.PP
-In the simple class definition shown above all member data and
-functions were publicly accessible.  The example that follows contrasts
-public, protected and privately accessible fields and shows how these
-protections are encoded in \*(C+ stabs.
-.PP
-If the character following the `\fBFIELD-NAME:\fR' part of the string is
-`\fB/\fR', then the next character is the visibility.  `\fB0\fR' means private, `\fB1\fR'
-means protected, and `\fB2\fR' means public.  Debuggers should ignore
-visibility characters they do not recognize, and assume a reasonable
-default (such as public) (\s-1GDB 4.11\s0 does not, but this should be fixed
-in the next \s-1GDB\s0 release).  If no visibility is specified the field is
-public.  The visibility `\fB9\fR' means that the field has been optimized out
-and is public (there is no way to specify an optimized out field with a
-private or protected visibility).  Visibility `\fB9\fR' is not supported by
-\&\s-1GDB 4.11\s0; this should be fixed in the next \s-1GDB\s0 release.
-.PP
-The following \*(C+ source:
-.PP
-class vis {
-private:
-int   priv;
-protected:
-char  prot;
-public:
-float pub;
-};
-.PP
-generates the following stab:
-.PP
-# 128 is N_LSYM
-\&.stabs \*(L"vis:T19=s12priv:/01,0,32;prot:/12,32,8;pub:12,64,32;;\*(R",128,0,0,0
-.PP
-`\fBvis:T19=s12\fR' indicates that type number 19 is a 12 byte structure
-named `\fBvis\fR' The `\fBpriv\fR' field has public visibility (`\fB/0\fR'), type int
-(`\fB1\fR'), and offset and size `\fB,0,32;\fR'.  The `\fBprot\fR' field has protected
-visibility (`\fB/1\fR'), type char (`\fB2\fR') and offset and size `\fB,32,8;\fR'.  The
-`\fBpub\fR' field has type float (`\fB12\fR'), and offset and size `\fB,64,32;\fR'.
-.PP
-Protections for member functions are signified by one digit embedded
-in the field part of the stab describing the method.  The digit is 0 if
-private, 1 if protected and 2 if public.  Consider the \*(C+ class
-definition below:
-.PP
-class all_methods {
-private:
-int   priv_meth(int in){return in;};
-protected:
-char  protMeth(char in){return in;};
-public:
-float pubMeth(float in){return in;};
-};
-.PP
-It generates the following stab.  The digit in question is to the
-left of an `\fBA\fR' in each case.  Notice also that in this case two symbol
-descriptors apply to the class name struct tag and struct type.
-.PP
-\&.stabs \*(L"class_name:sym_desc(struct tag&type)type_def(21)=
-sym_desc(struct)\fIstruct_bytes\fR\|(1)
-meth_name::type_def(22)=sym_desc(method)returning(int);
-:args(int);protection(private)modifier(normal)virtual(no);
-meth_name::type_def(23)=sym_desc(method)returning(char);
-:args(char);protection(protected)modifier(normal)virtual(no);
-meth_name::type_def(24)=sym_desc(method)returning(float);
-:args(float);protection(public)modifier(normal)virtual(no);;\*(R",
-N_LSYM,NIL,NIL,NIL
-.PP
-\&.stabs \*(L"all_methods:Tt21=s1priv_meth::22=##1;:i;0A.;protMeth::23=##2;:c;1A.;
-pubMeth::24=##12;:f;2A.;;\*(R",128,0,0,0
-.PP
-\&\fB8.10 Method Modifiers (`const', `volatile', `const volatile')\fR
-.PP
-<< based on a6.C >>
-.PP
-In the class example described above all the methods have the normal
-modifier.  This method modifier information is located just after the
-protection information for the method.  This field has four possible
-character values.  Normal methods use `\fBA\fR', const methods use `\fBB\fR',
-volatile methods use `\fBC\fR', and const volatile methods use `\fBD\fR'.  Consider
-the class definition below:
-.PP
-class A {
-public:
-int ConstMeth (int arg) const { return arg; };
-char VolatileMeth (char arg) volatile { return arg; };
-float ConstVolMeth (float arg) const volatile {return arg; };
-};
-.PP
-This class is described by the following stab:
-.PP
-\&.stabs \*(L"class(A):sym_desc(struct)type_def(20)=type_desc(struct)\fIstruct_bytes\fR\|(1)
-meth_name(ConstMeth)::type_def(21)sym_desc(method)
-returning(int);:arg(int);protection(public)modifier(const)virtual(no);
-meth_name(VolatileMeth)::type_def(22)=sym_desc(method)
-returning(char);:arg(char);protection(public)modifier(volatile)virt(no)
-meth_name(ConstVolMeth)::type_def(23)=sym_desc(method)
-returning(float);:arg(float);protection(public)modifier(const volatile)
-virtual(no);;\*(R", ...
-.PP
-\&.stabs \*(L"A:T20=s1ConstMeth::21=##1;:i;2B.;VolatileMeth::22=##2;:c;2C.;
-ConstVolMeth::23=##12;:f;2D.;;\*(R",128,0,0,0
-.PP
-\&\fB8.11 Virtual Methods\fR
-.PP
-<< The following examples are based on a4.C >>
-.PP
-The presence of virtual methods in a class definition adds additional
-data to the class description.  The extra data is appended to the
-description of the virtual method and to the end of the class
-description.  Consider the class definition below:
-.PP
-class A {
-public:
-int Adat;
-virtual int A_virt (int arg) { return arg; };
-};
-.PP
-This results in the stab below describing class A.  It defines a new
-type (20) which is an 8 byte structure.  The first field of the class
-struct is `\fBAdat\fR', an integer, starting at structure offset 0 and
-occupying 32 bits.
-.PP
-The second field in the class struct is not explicitly defined by the
-\&\*(C+ class definition but is implied by the fact that the class contains
-a virtual method.  This field is the vtable pointer.  The name of the
-vtable pointer field starts with `\fB\f(CB$vf\fB\fR' and continues with a type
-reference to the class it is part of.  In this example the type
-reference for class A is 20 so the name of its vtable pointer field is
-`\fB\f(CB$vf20\fB\fR', followed by the usual colon.
-.PP
-Next there is a type definition for the vtable pointer type (21).
-This is in turn defined as a pointer to another new type (22).
-.PP
-Type 22 is the vtable itself, which is defined as an array, indexed
-by a range of integers between 0 and 1, and whose elements are of type
-17.  Type 17 was the vtable record type defined by the boilerplate \*(C+
-type definitions, as shown earlier.
-.PP
-The bit offset of the vtable pointer field is 32.  The number of bits
-in the field are not specified when the field is a vtable pointer.
-.PP
-Next is the method definition for the virtual member function
-`\fBA_virt\fR'.  Its description starts out using the same format as the
-non-virtual member functions described above, except instead of a dot
-after the `\fBA\fR' there is an asterisk, indicating that the function is
-virtual.  Since is is virtual some addition information is appended to
-the end of the method description.
-.PP
-The first number represents the vtable index of the method.  This is
-a 32 bit unsigned number with the high bit set, followed by a
-semi-colon.
-.PP
-The second number is a type reference to the first base class in the
-inheritance hierarchy defining the virtual member function.  In this
-case the class stab describes a base class so the virtual function is
-not overriding any other definition of the method.  Therefore the
-reference is to the type number of the class that the stab is
-describing (20).
-.PP
-This is followed by three semi-colons.  One marks the end of the
-current sub-section, one marks the end of the method field, and the
-third marks the end of the struct definition.
-.PP
-For classes containing virtual functions the very last section of the
-string part of the stab holds a type reference to the first base class.
-This is preceded by `\fB~%\fR' and followed by a final semi-colon.
-.PP
-\&.stabs \*(L"class_name(A):type_def(20)=sym_desc(struct)\fIstruct_bytes\fR\|(8)
-field_name(Adat):type_ref(int),\fIbit_offset\fR\|(0),field_bits(32);
-field_name(A virt func ptr):type_def(21)=type_desc(ptr to)type_def(22)=
-sym_desc(array)index_type_ref(range of int from 0 to 1);
-elem_type_ref(vtbl elem type),
-bit_offset(32);
-meth_name(A_virt)::typedef(23)=sym_desc(method)returning(int);
-:arg_type(int),protection(public)normal(yes)virtual(yes)
-\&\fIvtable_index\fR\|(1);class_first_defining(A);;;~%first_base(A);\*(R",
-N_LSYM,NIL,NIL,NIL
-.PP
-\&.stabs \*(L"A:t20=s8Adat:1,0,32;$vf20:21=*22=ar1;0;1;17,32;
-A_virt::23=##1;:i;2A*\-2147483647;20;;;~%20;\*(R",128,0,0,0
-.PP
-\&\fB8.12 Inheritance\fR
-.PP
-Stabs describing \*(C+ derived classes include additional sections that
-describe the inheritance hierarchy of the class.  A derived class stab
-also encodes the number of base classes.  For each base class it tells
-if the base class is virtual or not, and if the inheritance is private
-or public.  It also gives the offset into the object of the portion of
-the object corresponding to each base class.
-.PP
-This additional information is embedded in the class stab following
-the number of bytes in the struct.  First the number of base classes
-appears bracketed by an exclamation point and a comma.
-.PP
-Then for each base type there repeats a series: a virtual character,
-a visibility character, a number, a comma, another number, and a
-semi-colon.
-.PP
-The virtual character is `\fB1\fR' if the base class is virtual and `\fB0\fR' if
-not.  The visibility character is `\fB2\fR' if the derivation is public, `\fB1\fR'
-if it is protected, and `\fB0\fR' if it is private.  Debuggers should ignore
-virtual or visibility characters they do not recognize, and assume a
-reasonable default (such as public and non-virtual) (\s-1GDB 4.11\s0 does not,
-but this should be fixed in the next \s-1GDB\s0 release).
-.PP
-The number following the virtual and visibility characters is the
-offset from the start of the object to the part of the object
-pertaining to the base class.
-.PP
-After the comma, the second number is a type_descriptor for the base
-type.  Finally a semi-colon ends the series, which repeats for each
-base class.
-.PP
-The source below defines three base classes `\fBA\fR', `\fBB\fR', and `\fBC\fR' and
-the derived class `\fBD\fR'.
-.PP
-class A {
-public:
-int Adat;
-virtual int A_virt (int arg) { return arg; };
-};
-.PP
-class B {
-public:
-int B_dat;
-virtual int B_virt (int arg) {return arg; };
-};
-.PP
-class C {
-public:
-int Cdat;
-virtual int C_virt (int arg) {return arg; };
-};
-.PP
-class D : A, virtual B, public C {
-public:
-int Ddat;
-virtual int A_virt (int arg ) { return arg+1; };
-virtual int B_virt (int arg)  { return arg+2; };
-virtual int C_virt (int arg)  { return arg+3; };
-virtual int D_virt (int arg)  { return arg; };
-};
-.PP
-Class stabs similar to the ones described earlier are generated for
-each base class.
-.PP
-\&.stabs \*(L"A:T20=s8Adat:1,0,32;$vf20:21=*22=ar1;0;1;17,32;
-A_virt::23=##1;:i;2A*\-2147483647;20;;;~%20;\*(R",128,0,0,0
-.PP
-\&.stabs \*(L"B:Tt25=s8Bdat:1,0,32;$vf25:21,32;B_virt::26=##1;
-:i;2A*\-2147483647;25;;;~%25;\*(R",128,0,0,0
-.PP
-\&.stabs \*(L"C:Tt28=s8Cdat:1,0,32;$vf28:21,32;C_virt::29=##1;
-:i;2A*\-2147483647;28;;;~%28;\*(R",128,0,0,0
-.PP
-In the stab describing derived class `\fBD\fR' below, the information about
-the derivation of this class is encoded as follows.
-.PP
-\&.stabs "derived_class_name:symbol_descriptors(struct tag&type)=
-type_descriptor(struct)struct_bytes(32)!\fInum_bases\fR\|(3),
-base_virtual(no)inheritance_public(no)\fIbase_offset\fR\|(0),
-base_class_type_ref(A);
-base_virtual(yes)inheritance_public(no)base_offset(\s-1NIL\s0),
-base_class_type_ref(B);
-base_virtual(no)inheritance_public(yes)base_offset(64),
-base_class_type_ref(C); ...
-.PP
-\&.stabs \*(L"D:Tt31=s32!3,000,20;100,25;0264,28;$vb25:24,128;Ddat:
-1,160,32;A_virt::32=##1;:i;2A*\-2147483647;20;;B_virt:
-:32:i;2A*\-2147483647;25;;C_virt::32:i;2A*\-2147483647;
-28;;D_virt::32:i;2A*\-2147483646;31;;;~%20;\*(R",128,0,0,0
-.PP
-\&\fB8.13 Virtual Base Classes\fR
-.PP
-A derived class object consists of a concatenation in memory of the data
-areas defined by each base class, starting with the leftmost and ending
-with the rightmost in the list of base classes.  The exception to this
-rule is for virtual inheritance.  In the example above, class `\fBD\fR'
-inherits virtually from base class `\fBB\fR'.  This means that an instance of
-a `\fBD\fR' object will not contain its own `\fBB\fR' part but merely a pointer to
-a `\fBB\fR' part, known as a virtual base pointer.
-.PP
-In a derived class stab, the base offset part of the derivation
-information, described above, shows how the base class parts are
-ordered.  The base offset for a virtual base class is always given as 0.
-Notice that the base offset for `\fBB\fR' is given as 0 even though `\fBB\fR' is
-not the first base class.  The first base class `\fBA\fR' starts at offset 0.
-.PP
-The field information part of the stab for class `\fBD\fR' describes the
-field which is the pointer to the virtual base class `\fBB\fR'. The vbase
-pointer name is `\fB\f(CB$vb\fB\fR' followed by a type reference to the virtual base
-class.  Since the type id for `\fBB\fR' in this example is 25, the vbase
-pointer name is `\fB\f(CB$vb25\fB\fR'.
-.PP
-\&.stabs \*(L"D:Tt31=s32!3,000,20;100,25;0264,28;$vb25:24,128;Ddat:1,
-160,32;A_virt::32=##1;:i;2A*\-2147483647;20;;B_virt::32:i;
-2A*\-2147483647;25;;C_virt::32:i;2A*\-2147483647;28;;D_virt:
-:32:i;2A*\-2147483646;31;;;~%20;\*(R",128,0,0,0
-.PP
-Following the name and a semicolon is a type reference describing the
-type of the virtual base class pointer, in this case 24.  Type 24 was
-defined earlier as the type of the `\fBB\fR' class `\fBthis\fR' pointer.  The
-`\fBthis\fR' pointer for a class is a pointer to the class type.
-.PP
-\&.stabs \*(L"this:P24=*25=xsB:\*(R",64,0,0,8
-.PP
-Finally the field offset part of the vbase pointer field description
-shows that the vbase pointer is the first field in the `\fBD\fR' object,
-before any data fields defined by the class.  The layout of a `\fBD\fR' class
-object is a follows, `\fBAdat\fR' at 0, the vtable pointer for `\fBA\fR' at 32,
-`\fBCdat\fR' at 64, the vtable pointer for C at 96, the virtual base pointer
-for `\fBB\fR' at 128, and `\fBDdat\fR' at 160.
-.PP
-\&\fB8.14 Static Members\fR
-.PP
-The data area for a class is a concatenation of the space used by the
-data members of the class.  If the class has virtual methods, a vtable
-pointer follows the class data.  The field offset part of each field
-description in the class stab shows this ordering.
-.PP
-<< How is this reflected in stabs?  See Cygnus bug #677 for some
-info.  >>
-.SS "Appendix A Table of Stab Types"
-.IX Subsection "Appendix A Table of Stab Types"
-The following are all the possible values for the stab type field, for
-a.out files, in numeric order.  This does not apply to \s-1XCOFF,\s0 but it
-does apply to stabs in sections (see \*(L"Stab Sections\*(R").  Stabs in
-\&\s-1ECOFF\s0 use these values but add 0x8f300 to distinguish them from non-stab
-symbols.
-.PP
-The symbolic names are defined in the file `\fBinclude/aout/stabs.def\fR'.
-.PP
-* Menu:
-.PP
-Types from 0 to 0x1f: see \*(L"Non-Stab Symbol Types\*(R"
-.PP
-Types from 0x20 to 0xff: see \*(L"Stab Symbol Types\*(R"
-.PP
-\&\fBA.1 Non-Stab Symbol Types\fR
-.PP
-The following types are used by the linker and assembler, not by stab
-directives.  Since this document does not attempt to describe aspects of
-object file format other than the debugging format, no details are
-given.
-.PP
-`\fB0x0     N_UNDF\fR'
-Undefined symbol
-.PP
-`\fB0x2     N_ABS\fR'
-File scope absolute symbol
-.PP
-`\fB0x3     N_ABS | N_EXT\fR'
-External absolute symbol
-.PP
-`\fB0x4     N_TEXT\fR'
-File scope text symbol
-.PP
-`\fB0x5     N_TEXT | N_EXT\fR'
-External text symbol
-.PP
-`\fB0x6     N_DATA\fR'
-File scope data symbol
-.PP
-`\fB0x7     N_DATA | N_EXT\fR'
-External data symbol
-.PP
-`\fB0x8     N_BSS\fR'
-File scope \s-1BSS\s0 symbol
-.PP
-`\fB0x9     N_BSS | N_EXT\fR'
-External \s-1BSS\s0 symbol
-.PP
-`\fB0x0c    N_FN_SEQ\fR'
-Same as `\fBN_FN\fR', for Sequent compilers
-.PP
-`\fB0x0a    N_INDR\fR'
-Symbol is indirected to another symbol
-.PP
-`\fB0x12    N_COMM\fR'
-Common\*(--visible after shared library dynamic link
-.PP
-`\fB0x14 N_SETA\fR'
-`\fB0x15 N_SETA | N_EXT\fR'
-Absolute set element
-.PP
-`\fB0x16 N_SETT\fR'
-`\fB0x17 N_SETT | N_EXT\fR'
-Text segment set element
-.PP
-`\fB0x18 N_SETD\fR'
-`\fB0x19 N_SETD | N_EXT\fR'
-Data segment set element
-.PP
-`\fB0x1a N_SETB\fR'
-`\fB0x1b N_SETB | N_EXT\fR'
-\&\s-1BSS\s0 segment set element
-.PP
-`\fB0x1c N_SETV\fR'
-`\fB0x1d N_SETV | N_EXT\fR'
-Pointer to set vector
-.PP
-`\fB0x1e N_WARNING\fR'
-Print a warning message during linking
-.PP
-`\fB0x1f    N_FN\fR'
-File name of a `\fB.o\fR' file
-.PP
-\&\fBA.2 Stab Symbol Types\fR
-.PP
-The following symbol types indicate that this is a stab.  This is the
-full list of stab numbers, including stab types that are used in
-languages other than C.
-.PP
-`\fB0x20     N_GSYM\fR'
-Global symbol; see see \*(L"Global Variables\*(R".
-.PP
-`\fB0x22     N_FNAME\fR'
-Function name (for \s-1BSD\s0 Fortran); see see \*(L"Procedures\*(R".
-.PP
-`\fB0x24     N_FUN\fR'
-Function name (see \*(L"Procedures\*(R") or text segment variable (*note
-Statics::).
-.PP
-`\fB0x26 N_STSYM\fR'
-Data segment file-scope variable; see see \*(L"Statics\*(R".
-.PP
-`\fB0x28 N_LCSYM\fR'
-\&\s-1BSS\s0 segment file-scope variable; see see \*(L"Statics\*(R".
-.PP
-`\fB0x2a N_MAIN\fR'
-Name of main routine; see see \*(L"Main Program\*(R".
-.PP
-`\fB0x2c N_ROSYM\fR'
-Variable in `\fB.rodata\fR' section; see see \*(L"Statics\*(R".
-.PP
-`\fB0x30     N_PC\fR'
-Global symbol (for Pascal); see see \*(L"N_PC\*(R".
-.PP
-`\fB0x32     N_NSYMS\fR'
-Number of symbols (according to Ultrix V4.0); see see \*(L"N_NSYMS\*(R".
-.PP
-`\fB0x34     N_NOMAP\fR'
-No \s-1DST\s0 map; see see \*(L"N_NOMAP\*(R".
-.PP
-`\fB0x36     N_MAC_DEFINE\fR'
-Name and body of a `\fB#define\fR'd macro; see *note Macro define and
-undefine::.
-.PP
-`\fB0x38 N_OBJ\fR'
-Object file (Solaris2).
-.PP
-`\fB0x3a     N_MAC_UNDEF\fR'
-Name of an `\fB#undef\fR'ed macro; see see \*(L"Macro define and undefine\*(R".
-.PP
-`\fB0x3c N_OPT\fR'
-Debugger options (Solaris2).
-.PP
-`\fB0x40     N_RSYM\fR'
-Register variable; see see \*(L"Register Variables\*(R".
-.PP
-`\fB0x42     N_M2C\fR'
-Modula\-2 compilation unit; see see \*(L"N_M2C\*(R".
-.PP
-`\fB0x44     N_SLINE\fR'
-Line number in text segment; see see \*(L"Line Numbers\*(R".
-.PP
-`\fB0x46     N_DSLINE\fR'
-Line number in data segment; see see \*(L"Line Numbers\*(R".
-.PP
-`\fB0x48     N_BSLINE\fR'
-Line number in bss segment; see see \*(L"Line Numbers\*(R".
-.PP
-`\fB0x48     N_BROWS\fR'
-Sun source code browser, path to `\fB.cb\fR' file; see see \*(L"N_BROWS\*(R".
-.PP
-`\fB0x4a     N_DEFD\fR'
-\&\s-1GNU\s0 Modula2 definition module dependency; see see \*(L"N_DEFD\*(R".
-.PP
-`\fB0x4c N_FLINE\fR'
-Function start/body/end line numbers (Solaris2).
-.PP
-`\fB0x50     N_EHDECL\fR'
-\&\s-1GNU \*(C+\s0 exception variable; see see \*(L"N_EHDECL\*(R".
-.PP
-`\fB0x50     N_MOD2\fR'
-Modula2 info \*(L"for imc\*(R" (according to Ultrix V4.0); see *note
-N_MOD2::.
-.PP
-`\fB0x54     N_CATCH\fR'
-\&\s-1GNU \*(C+\s0 `\fBcatch\fR' clause; see see \*(L"N_CATCH\*(R".
-.PP
-`\fB0x60     N_SSYM\fR'
-Structure of union element; see see \*(L"N_SSYM\*(R".
-.PP
-`\fB0x62 N_ENDM\fR'
-Last stab for module (Solaris2).
-.PP
-`\fB0x64     N_SO\fR'
-Path and name of source file; see see \*(L"Source Files\*(R".
-.PP
-`\fB0x80 N_LSYM\fR'
-Stack variable (see \*(L"Stack Variables\*(R") or type (*note
-Typedefs::).
-.PP
-`\fB0x82     N_BINCL\fR'
-Beginning of an include file (Sun only); see see \*(L"Include Files\*(R".
-.PP
-`\fB0x84     N_SOL\fR'
-Name of include file; see see \*(L"Include Files\*(R".
-.PP
-`\fB0xa0     N_PSYM\fR'
-Parameter variable; see see \*(L"Parameters\*(R".
-.PP
-`\fB0xa2     N_EINCL\fR'
-End of an include file; see see \*(L"Include Files\*(R".
-.PP
-`\fB0xa4     N_ENTRY\fR'
-Alternate entry point; see see \*(L"Alternate Entry Points\*(R".
-.PP
-`\fB0xc0     N_LBRAC\fR'
-Beginning of a lexical block; see see \*(L"Block Structure\*(R".
-.PP
-`\fB0xc2     N_EXCL\fR'
-Place holder for a deleted include file; see see \*(L"Include Files\*(R".
-.PP
-`\fB0xc4     N_SCOPE\fR'
-Modula2 scope information (Sun linker); see see \*(L"N_SCOPE\*(R".
-.PP
-`\fB0xe0     N_RBRAC\fR'
-End of a lexical block; see see \*(L"Block Structure\*(R".
-.PP
-`\fB0xe2     N_BCOMM\fR'
-Begin named common block; see see \*(L"Common Blocks\*(R".
-.PP
-`\fB0xe4     N_ECOMM\fR'
-End named common block; see see \*(L"Common Blocks\*(R".
-.PP
-`\fB0xe8     N_ECOML\fR'
-Member of a common block; see see \*(L"Common Blocks\*(R".
-.PP
-`\fB0xea N_WITH\fR'
-Pascal `\fBwith\fR' statement: type,,0,0,offset (Solaris2).
-.PP
-`\fB0xf0     N_NBTEXT\fR'
-Gould non-base registers; see see \*(L"Gould\*(R".
-.PP
-`\fB0xf2     N_NBDATA\fR'
-Gould non-base registers; see see \*(L"Gould\*(R".
-.PP
-`\fB0xf4     N_NBBSS\fR'
-Gould non-base registers; see see \*(L"Gould\*(R".
-.PP
-`\fB0xf6     N_NBSTS\fR'
-Gould non-base registers; see see \*(L"Gould\*(R".
-.PP
-`\fB0xf8     N_NBLCS\fR'
-Gould non-base registers; see see \*(L"Gould\*(R".
-.SS "Appendix B Table of Symbol Descriptors"
-.IX Subsection "Appendix B Table of Symbol Descriptors"
-The symbol descriptor is the character which follows the colon in many
-stabs, and which tells what kind of stab it is.  see \*(L"String Field\*(R",
-for more information about their use.
-.PP
-`\fB\s-1DIGIT\s0\fR'
-`\fB(\fR'
-`\fB\-\fR'
-Variable on the stack; see see \*(L"Stack Variables\*(R".
-.PP
-`\fB:\fR'
-\&\*(C+ nested symbol; see see \*(L"Nested Symbols\*(R".
-.PP
-`\fBa\fR'
-Parameter passed by reference in register; see *note Reference
-Parameters::.
-.PP
-`\fBb\fR'
-Based variable; see see \*(L"Based Variables\*(R".
-.PP
-`\fBc\fR'
-Constant; see see \*(L"Constants\*(R".
-.PP
-`\fBC\fR'
-Conformant array bound (Pascal, maybe other languages); *note
-Conformant Arrays::.  Name of a caught exception (\s-1GNU \*(C+\s0).  These
-can be distinguished because the latter uses `\fBN_CATCH\fR' and the
-former uses another symbol type.
-.PP
-`\fBd\fR'
-Floating point register variable; see see \*(L"Register Variables\*(R".
-.PP
-`\fBD\fR'
-Parameter in floating point register; see *note Register
-Parameters::.
-.PP
-`\fBf\fR'
-File scope function; see see \*(L"Procedures\*(R".
-.PP
-`\fBF\fR'
-Global function; see see \*(L"Procedures\*(R".
-.PP
-`\fBG\fR'
-Global variable; see see \*(L"Global Variables\*(R".
-.PP
-`\fBi\fR'
-see \*(L"Register Parameters\*(R".
-.PP
-`\fBI\fR'
-Internal (nested) procedure; see see \*(L"Nested Procedures\*(R".
-.PP
-`\fBJ\fR'
-Internal (nested) function; see see \*(L"Nested Procedures\*(R".
-.PP
-`\fBL\fR'
-Label name (documented by \s-1AIX,\s0 no further information known).
-.PP
-`\fBm\fR'
-Module; see see \*(L"Procedures\*(R".
-.PP
-`\fBp\fR'
-Argument list parameter; see see \*(L"Parameters\*(R".
-.PP
-`\fBpP\fR'
-see \*(L"Parameters\*(R".
-.PP
-`\fBpF\fR'
-Fortran Function parameter; see see \*(L"Parameters\*(R".
-.PP
-`\fBP\fR'
-Unfortunately, three separate meanings have been independently
-invented for this symbol descriptor.  At least the \s-1GNU\s0 and Sun
-uses can be distinguished by the symbol type.  Global Procedure
-(\s-1AIX\s0) (symbol type used unknown); see see \*(L"Procedures\*(R".
-Register parameter (\s-1GNU\s0) (symbol type `\fBN_PSYM\fR'); see *note
-Parameters::.  Prototype of function referenced by this file (Sun
-`\fBacc\fR') (symbol type `\fBN_FUN\fR').
-.PP
-`\fBQ\fR'
-Static Procedure; see see \*(L"Procedures\*(R".
-.PP
-`\fBR\fR'
-Register parameter; see see \*(L"Register Parameters\*(R".
-.PP
-`\fBr\fR'
-Register variable; see see \*(L"Register Variables\*(R".
-.PP
-`\fBS\fR'
-File scope variable; see see \*(L"Statics\*(R".
-.PP
-`\fBs\fR'
-Local variable (\s-1OS9000\s0).
-.PP
-`\fBt\fR'
-Type name; see see \*(L"Typedefs\*(R".
-.PP
-`\fBT\fR'
-Enumeration, structure, or union tag; see see \*(L"Typedefs\*(R".
-.PP
-`\fBv\fR'
-Parameter passed by reference; see see \*(L"Reference Parameters\*(R".
-.PP
-`\fBV\fR'
-Procedure scope static variable; see see \*(L"Statics\*(R".
-.PP
-`\fBx\fR'
-Conformant array; see see \*(L"Conformant Arrays\*(R".
-.PP
-`\fBX\fR'
-Function return variable; see see \*(L"Parameters\*(R".
-.SS "Appendix C Table of Type Descriptors"
-.IX Subsection "Appendix C Table of Type Descriptors"
-The type descriptor is the character which follows the type number and
-an equals sign.  It specifies what kind of type is being defined.
-see \*(L"String Field\*(R", for more information about their use.
-.PP
-`\fB\s-1DIGIT\s0\fR'
-`\fB(\fR'
-Type reference; see see \*(L"String Field\*(R".
-.PP
-`\fB\-\fR'
-Reference to builtin type; see see \*(L"Negative Type Numbers\*(R".
-.PP
-`\fB#\fR'
-Method (\*(C+); see see \*(L"Method Type Descriptor\*(R".
-.PP
-`\fB*\fR'
-Pointer; see see \*(L"Miscellaneous Types\*(R".
-.PP
-`\fB&\fR'
-Reference (\*(C+).
-.PP
-`\fB@\fR'
-Type Attributes (\s-1AIX\s0); see see \*(L"String Field\*(R".  Member (class
-and variable) type (\s-1GNU \*(C+\s0); see see \*(L"Member Type Descriptor\*(R".
-.PP
-`\fBa\fR'
-Array; see see \*(L"Arrays\*(R".
-.PP
-`\fBA\fR'
-Open array; see see \*(L"Arrays\*(R".
-.PP
-`\fBb\fR'
-Pascal space type (\s-1AIX\s0); see see \*(L"Miscellaneous Types\*(R".  Builtin
-integer type (Sun); see see \*(L"Builtin Type Descriptors\*(R".  Const
-and volatile qualified type (\s-1OS9000\s0).
-.PP
-`\fBB\fR'
-Volatile-qualified type; see see \*(L"Miscellaneous Types\*(R".
-.PP
-`\fBc\fR'
-Complex builtin type (\s-1AIX\s0); see see \*(L"Builtin Type Descriptors\*(R".
-Const-qualified type (\s-1OS9000\s0).
-.PP
-`\fBC\fR'
-\&\s-1COBOL\s0 Picture type.  See \s-1AIX\s0 documentation for details.
-.PP
-`\fBd\fR'
-File type; see see \*(L"Miscellaneous Types\*(R".
-.PP
-`\fBD\fR'
-N\-dimensional dynamic array; see see \*(L"Arrays\*(R".
-.PP
-`\fBe\fR'
-Enumeration type; see see \*(L"Enumerations\*(R".
-.PP
-`\fBE\fR'
-N\-dimensional subarray; see see \*(L"Arrays\*(R".
-.PP
-`\fBf\fR'
-Function type; see see \*(L"Function Types\*(R".
-.PP
-`\fBF\fR'
-Pascal function parameter; see see \*(L"Function Types\*(R"
-.PP
-`\fBg\fR'
-Builtin floating point type; see see \*(L"Builtin Type Descriptors\*(R".
-.PP
-`\fBG\fR'
-\&\s-1COBOL\s0 Group.  See \s-1AIX\s0 documentation for details.
-.PP
-`\fBi\fR'
-Imported type (\s-1AIX\s0); see see \*(L"Cross-References\*(R".
-Volatile-qualified type (\s-1OS9000\s0).
-.PP
-`\fBk\fR'
-Const-qualified type; see see \*(L"Miscellaneous Types\*(R".
-.PP
-`\fBK\fR'
-\&\s-1COBOL\s0 File Descriptor.  See \s-1AIX\s0 documentation for details.
-.PP
-`\fBM\fR'
-Multiple instance type; see see \*(L"Miscellaneous Types\*(R".
-.PP
-`\fBn\fR'
-String type; see see \*(L"Strings\*(R".
-.PP
-`\fBN\fR'
-Stringptr; see see \*(L"Strings\*(R".
-.PP
-`\fBo\fR'
-Opaque type; see see \*(L"Typedefs\*(R".
-.PP
-`\fBp\fR'
-Procedure; see see \*(L"Function Types\*(R".
-.PP
-`\fBP\fR'
-Packed array; see see \*(L"Arrays\*(R".
-.PP
-`\fBr\fR'
-Range type; see see \*(L"Subranges\*(R".
-.PP
-`\fBR\fR'
-Builtin floating type; see see \*(L"Builtin Type Descriptors\*(R" (Sun).
-Pascal subroutine parameter; see see \*(L"Function Types\*(R" (\s-1AIX\s0).
-Detecting this conflict is possible with careful parsing (hint: a
-Pascal subroutine parameter type will always contain a comma, and
-a builtin type descriptor never will).
-.PP
-`\fBs\fR'
-Structure type; see see \*(L"Structures\*(R".
-.PP
-`\fBS\fR'
-Set type; see see \*(L"Miscellaneous Types\*(R".
-.PP
-`\fBu\fR'
-Union; see see \*(L"Unions\*(R".
-.PP
-`\fBv\fR'
-Variant record.  This is a Pascal and Modula\-2 feature which is
-like a union within a struct in C.  See \s-1AIX\s0 documentation for
-details.
-.PP
-`\fBw\fR'
-Wide character; see see \*(L"Builtin Type Descriptors\*(R".
-.PP
-`\fBx\fR'
-Cross-reference; see see \*(L"Cross-References\*(R".
-.PP
-`\fBY\fR'
-Used by \s-1IBM\s0's xlC \*(C+ compiler (for structures, I think).
-.PP
-`\fBz\fR'
-gstring; see see \*(L"Strings\*(R".
-.SS "Appendix D Expanded Reference by Stab Type"
-.IX Subsection "Appendix D Expanded Reference by Stab Type"
-For a full list of stab types, and cross-references to where they are
-described, see see \*(L"Stab Types\*(R".  This appendix just covers certain
-stabs which are not yet described in the main body of this document;
-eventually the information will all be in one place.
-.PP
-Format of an entry:
-.PP
-The first line is the symbol type (see `\fBinclude/aout/stab.def\fR').
-.PP
-The second line describes the language constructs the symbol type
-represents.
-.PP
-The third line is the stab format with the significant stab fields
-named and the rest \s-1NIL.\s0
-.PP
-Subsequent lines expand upon the meaning and possible values for each
-significant stab field.
-.PP
-Finally, any further information.
-.PP
-* Menu:
-.PP
-Pascal global symbol: see \*(L"N_PC\*(R"
-.PP
-Number of symbols: see \*(L"N_NSYMS\*(R"
-.PP
-No \s-1DST\s0 map: see \*(L"N_NOMAP\*(R"
-.PP
-Modula\-2 compilation unit: see \*(L"N_M2C\*(R"
-.PP
-Path to .cb file for Sun source code browser: see \*(L"N_BROWS\*(R"
-.PP
-\&\s-1GNU\s0 Modula2 definition module dependency: see \*(L"N_DEFD\*(R"
-.PP
-\&\s-1GNU \*(C+\s0 exception variable: see \*(L"N_EHDECL\*(R"
-.PP
-Modula2 information \*(L"for imc\*(R": see \*(L"N_MOD2\*(R"
-.PP
-\&\s-1GNU \*(C+ \s0\*(L"catch\*(R" clause: see \*(L"N_CATCH\*(R"
-.PP
-Structure or union element: see \*(L"N_SSYM\*(R"
-.PP
-Modula2 scope information (Sun only): see \*(L"N_SCOPE\*(R"
-.PP
-non-base register symbols used on Gould systems: see \*(L"Gould\*(R"
-.PP
-Length of preceding entry: see \*(L"N_LENG\*(R"
-.PP
-\&\fBD.1 N_PC\fR
-.PP
-\&\-\- `\fB.stabs\fR': N_PC
-Global symbol (for Pascal).
-.PP
-\&\*(L"name\*(R" \-> \*(L"symbol_name\*(R"  <<?>>
-value  \-> supposedly the line number (stab.def is skeptical)
-.PP
-`\fBstabdump.c\fR' says:
-.PP
-global pascal symbol: name,,0,subtype,line
-<< subtype? >>
-.PP
-\&\fBD.2 N_NSYMS\fR
-.PP
-\&\-\- `\fB.stabn\fR': N_NSYMS
-Number of symbols (according to Ultrix V4.0).
-.PP
-0, files,,funcs,lines (stab.def)
-.PP
-\&\fBD.3 N_NOMAP\fR
-.PP
-\&\-\- `\fB.stabs\fR': N_NOMAP
-No \s-1DST\s0 map for symbol (according to Ultrix V4.0).  I think this
-means a variable has been optimized out.
-.PP
-name, ,0,type,ignored (stab.def)
-.PP
-\&\fBD.4 N_M2C\fR
-.PP
-\&\-\- `\fB.stabs\fR': N_M2C
-Modula\-2 compilation unit.
-.PP
-\&\*(L"string\*(R" \-> \*(L"unit_name,unit_time_stamp[,code_time_stamp]\*(R"
-desc   \-> unit_number
-value  \-> 0 (main unit)
-1 (any other unit)
-.PP
-See `\fBDbx and Dbxtool Interfaces\fR', 2nd edition, by Sun, 1988, for
-more information.
-.PP
-\&\fBD.5 N_BROWS\fR
-.PP
-\&\-\- `\fB.stabs\fR': N_BROWS
-Sun source code browser, path to `\fB.cb\fR' file
-.PP
-<<?>> "path to associated `\fB.cb\fR' file"
-.PP
-Note: N_BROWS has the same value as N_BSLINE.
-.PP
-\&\fBD.6 N_DEFD\fR
-.PP
-\&\-\- `\fB.stabn\fR': N_DEFD
-\&\s-1GNU\s0 Modula2 definition module dependency.
-.PP
-\&\s-1GNU\s0 Modula\-2 definition module dependency.  The value is the
-modification time of the definition file.  The other field is
-non-zero if it is imported with the \s-1GNU M2\s0 keyword `\fB\f(CB%INITIALIZE\fB\fR'.
-Perhaps `\fBN_M2C\fR' can be used if there are enough empty fields?
-.PP
-\&\fBD.7 N_EHDECL\fR
-.PP
-\&\-\- `\fB.stabs\fR': N_EHDECL
-\&\s-1GNU \*(C+\s0 exception variable <<?>>.
-.PP
-\&\*(L"\s-1STRING\s0 is variable name\*(R"
-.PP
-Note: conflicts with `\fBN_MOD2\fR'.
-.PP
-\&\fBD.8 N_MOD2\fR
-.PP
-\&\-\- `\fB.stab?\fR': N_MOD2
-Modula2 info \*(L"for imc\*(R" (according to Ultrix V4.0)
-.PP
-Note: conflicts with `\fBN_EHDECL\fR'  <<?>>
-.PP
-\&\fBD.9 N_CATCH\fR
-.PP
-\&\-\- `\fB.stabn\fR': N_CATCH
-\&\s-1GNU \*(C+\s0 `\fBcatch\fR' clause
-.PP
-\&\s-1GNU \*(C+\s0 `\fBcatch\fR' clause.  The value is its address.  The desc field
-is nonzero if this entry is immediately followed by a `\fB\s-1CAUGHT\s0\fR' stab
-saying what exception was caught.  Multiple `\fB\s-1CAUGHT\s0\fR' stabs means
-that multiple exceptions can be caught here.  If desc is 0, it
-means all exceptions are caught here.
-.PP
-\&\fBD.10 N_SSYM\fR
-.PP
-\&\-\- `\fB.stabn\fR': N_SSYM
-Structure or union element.
-.PP
-The value is the offset in the structure.
-.PP
-<<?looking at structs and unions in C I didn't see these>>
-.PP
-\&\fBD.11 N_SCOPE\fR
-.PP
-\&\-\- `\fB.stab?\fR': N_SCOPE
-Modula2 scope information (Sun linker) <<?>>
-.PP
-\&\fBD.12 Non-base registers on Gould systems\fR
-.PP
-\&\-\- `\fB.stab?\fR': N_NBTEXT
-\&\*(-- `\fB.stab?\fR': N_NBDATA
-\&\*(-- `\fB.stab?\fR': N_NBBSS
-\&\*(-- `\fB.stab?\fR': N_NBSTS
-\&\*(-- `\fB.stab?\fR': N_NBLCS
-These are used on Gould systems for non-base registers syms.
-.PP
-However, the following values are not the values used by Gould;
-they are the values which \s-1GNU\s0 has been documenting for these
-values for a long time, without actually checking what Gould uses.
-I include these values only because perhaps some someone actually
-did something with the \s-1GNU\s0 information (I hope not, why \s-1GNU\s0
-knowingly assigned wrong values to these in the header file is a
-complete mystery to me).
-.PP
-240    0xf0     N_NBTEXT  ??
-242    0xf2     N_NBDATA  ??
-244    0xf4     N_NBBSS   ??
-246    0xf6     N_NBSTS   ??
-248    0xf8     N_NBLCS   ??
-.PP
-\&\fBD.13 N_LENG\fR
-.PP
-\&\-\- `\fB.stabn\fR': N_LENG
-Second symbol entry containing a length-value for the preceding
-entry.  The value is the length.
-.SS "Appendix E Questions and Anomalies"
-.IX Subsection "Appendix E Questions and Anomalies"
-* For \s-1GNU C\s0 stabs defining local and global variables (`\fBN_LSYM\fR' and
-`\fBN_GSYM\fR'), the desc field is supposed to contain the source line
-number on which the variable is defined.  In reality the desc
-field is always 0.  (This behavior is defined in `\fBdbxout.c\fR' and
-putting a line number in desc is controlled by `#ifdef
-\&\s-1WINNING_GDB\s0', which defaults to false). \s-1GDB\s0 supposedly uses this
-information if you say `\fBlist \s-1VAR\s0\fR'.  In reality, \s-1VAR\s0 can be a
-variable defined in the program and \s-1GDB\s0 says `function \s-1VAR\s0 not
-defined'.
-.PP
-* In \s-1GNU C\s0 stabs, there seems to be no way to differentiate tag
-types: structures, unions, and enums (symbol descriptor `\fBT\fR') and
-typedefs (symbol descriptor `\fBt\fR') defined at file scope from types
-defined locally to a procedure or other more local scope.  They
-all use the `\fBN_LSYM\fR' stab type.  Types defined at procedure scope
-are emitted after the `\fBN_RBRAC\fR' of the preceding function and
-before the code of the procedure in which they are defined.  This
-is exactly the same as types defined in the source file between
-the two procedure bodies.  \s-1GDB\s0 over-compensates by placing all
-types in block #1, the block for symbols of file scope.  This is
-true for default, `\fB\-ansi\fR' and `\fB\-traditional\fR' compiler options.
-(Bugs gcc/1063, gdb/1066.)
-.PP
-* What ends the procedure scope?  Is it the proc block's `\fBN_RBRAC\fR'
-or the next `\fBN_FUN\fR'?  (I believe its the first.)
-.SS "Appendix F Using Stabs in Their Own Sections"
-.IX Subsection "Appendix F Using Stabs in Their Own Sections"
-Many object file formats allow tools to create object files with custom
-sections containing any arbitrary data.  For any such object file
-format, stabs can be embedded in special sections.  This is how stabs
-are used with \s-1ELF\s0 and \s-1SOM,\s0 and aside from \s-1ECOFF\s0 and \s-1XCOFF,\s0 is how stabs
-are used with \s-1COFF.\s0
-.PP
-* Menu:
-.PP
-How to embed stabs in sections: see \*(L"Stab Section Basics\*(R"
-.PP
-Sun \s-1ELF\s0 hacks: see \*(L"\s-1ELF\s0 Linker Relocation\*(R"
-.PP
-\&\fBF.1 How to Embed Stabs in Sections\fR
-.PP
-The assembler creates two custom sections, a section named `\fB.stab\fR'
-which contains an array of fixed length structures, one struct per stab,
-and a section named `\fB.stabstr\fR' containing all the variable length
-strings that are referenced by stabs in the `\fB.stab\fR' section.  The byte
-order of the stabs binary data depends on the object file format.  For
-\&\s-1ELF,\s0 it matches the byte order of the \s-1ELF\s0 file itself, as determined
-from the `\fB\s-1EI_DATA\s0\fR' field in the `\fBe_ident\fR' member of the \s-1ELF\s0 header.
-For \s-1SOM,\s0 it is always big-endian (is this true??? \s-1FIXME\s0).  For \s-1COFF,\s0 it
-matches the byte order of the \s-1COFF\s0 headers.  The meaning of the fields
-is the same as for a.out (see \*(L"Symbol Table Format\*(R"), except that the
-`\fBn_strx\fR' field is relative to the strings for the current compilation
-unit (which can be found using the synthetic N_UNDF stab described
-below), rather than the entire string table.
-.PP
-The first stab in the `\fB.stab\fR' section for each compilation unit is
-synthetic, generated entirely by the assembler, with no corresponding
-`\fB.stab\fR' directive as input to the assembler.  This stab contains the
-following fields:
-.PP
-`\fBn_strx\fR'
-Offset in the `\fB.stabstr\fR' section to the source filename.
-.PP
-`\fBn_type\fR'
-`\fBN_UNDF\fR'.
-.PP
-`\fBn_other\fR'
-Unused field, always zero.  This may eventually be used to hold
-overflows from the count in the `\fBn_desc\fR' field.
-.PP
-`\fBn_desc\fR'
-Count of upcoming symbols, i.e., the number of remaining stabs for
-this source file.
-.PP
-`\fBn_value\fR'
-Size of the string table fragment associated with this source
-file, in bytes.
-.PP
-The `\fB.stabstr\fR' section always starts with a null byte (so that string
-offsets of zero reference a null string), followed by random length
-strings, each of which is null byte terminated.
-.PP
-The \s-1ELF\s0 section header for the `\fB.stab\fR' section has its `\fBsh_link\fR'
-member set to the section number of the `\fB.stabstr\fR' section, and the
-`\fB.stabstr\fR' section has its \s-1ELF\s0 section header `\fBsh_type\fR' member set to
-`\fB\s-1SHT_STRTAB\s0\fR' to mark it as a string table.  \s-1SOM\s0 and \s-1COFF\s0 have no way of
-linking the sections together or marking them as string tables.
-.PP
-For \s-1COFF,\s0 the `\fB.stab\fR' and `\fB.stabstr\fR' sections may be simply
-concatenated by the linker.  \s-1GDB\s0 then uses the `\fBn_desc\fR' fields to
-figure out the extent of the original sections.  Similarly, the
-`\fBn_value\fR' fields of the header symbols are added together in order to
-get the actual position of the strings in a desired `\fB.stabstr\fR' section.
-Although this design obviates any need for the linker to relocate or
-otherwise manipulate `\fB.stab\fR' and `\fB.stabstr\fR' sections, it also requires
-some care to ensure that the offsets are calculated correctly.  For
-instance, if the linker were to pad in between the `\fB.stabstr\fR' sections
-before concatenating, then the offsets to strings in the middle of the
-executable's `\fB.stabstr\fR' section would be wrong.
-.PP
-The \s-1GNU\s0 linker is able to optimize stabs information by merging
-duplicate strings and removing duplicate header file information (*note
-Include Files::).  When some versions of the \s-1GNU\s0 linker optimize stabs
-in sections, they remove the leading `\fBN_UNDF\fR' symbol and arranges for
-all the `\fBn_strx\fR' fields to be relative to the start of the `\fB.stabstr\fR'
-section.
-.PP
-\&\fBF.2 Having the Linker Relocate Stabs in \s-1ELF\s0\fR
-.PP
-This section describes some Sun hacks for Stabs in \s-1ELF\s0; it does not
-apply to \s-1COFF\s0 or \s-1SOM.\s0
-.PP
-To keep linking fast, you don't want the linker to have to relocate
-very many stabs.  Making sure this is done for `\fBN_SLINE\fR', `\fBN_RBRAC\fR',
-and `\fBN_LBRAC\fR' stabs is the most important thing (see the descriptions
-of those stabs for more information).  But Sun's stabs in \s-1ELF\s0 has taken
-this further, to make all addresses in the `\fBn_value\fR' field (functions
-and static variables) relative to the source file.  For the `\fBN_SO\fR'
-symbol itself, Sun simply omits the address.  To find the address of
-each section corresponding to a given source file, the compiler puts
-out symbols giving the address of each section for a given source file.
-Since these are \s-1ELF \s0(not stab) symbols, the linker relocates them
-correctly without having to touch the stabs section.  They are named
-`\fBBbss.bss\fR' for the bss section, `\fBDdata.data\fR' for the data section, and
-`\fBDrodata.rodata\fR' for the rodata section.  For the text section, there
-is no such symbol (but there should be, see below).  For an example of
-how these symbols work, see \*(L"Stab Section Transformations\*(R".  \s-1GCC\s0 does
-not provide these symbols; it instead relies on the stabs getting
-relocated.  Thus addresses which would normally be relative to
-`\fBBbss.bss\fR', etc., are already relocated.  The Sun linker provided with
-Solaris 2.2 and earlier relocates stabs using normal \s-1ELF\s0 relocation
-information, as it would do for any section.  Sun has been threatening
-to kludge their linker to not do this (to speed up linking), even
-though the correct way to avoid having the linker do these relocations
-is to have the compiler no longer output relocatable values.  Last I
-heard they had been talked out of the linker kludge.  See Sun point
-patch 101052\-01 and Sun bug 1142109.  With the Sun compiler this
-affects `\fBS\fR' symbol descriptor stabs (see \*(L"Statics\*(R") and functions
-(see \*(L"Procedures\*(R").  In the latter case, to adopt the clean solution
-(making the value of the stab relative to the start of the compilation
-unit), it would be necessary to invent a `\fBTtext.text\fR' symbol, analogous
-to the `\fBBbss.bss\fR', etc., symbols.  I recommend this rather than using a
-zero value and getting the address from the \s-1ELF\s0 symbols.
-.PP
-Finding the correct `\fBBbss.bss\fR', etc., symbol is difficult, because
-the linker simply concatenates the `\fB.stab\fR' sections from each `\fB.o\fR' file
-without including any information about which part of a `\fB.stab\fR' section
-comes from which `\fB.o\fR' file.  The way \s-1GDB\s0 does this is to look for an
-\&\s-1ELF\s0 `\fB\s-1STT_FILE\s0\fR' symbol which has the same name as the last component of
-the file name from the `\fBN_SO\fR' symbol in the stabs (for example, if the
-file name is `\fB../../gdb/main.c\fR', it looks for an \s-1ELF\s0 `\fB\s-1STT_FILE\s0\fR' symbol
-named `\fBmain.c\fR').  This loses if different files have the same name
-(they could be in different directories, a library could have been
-copied from one system to another, etc.).  It would be much cleaner to
-have the `\fBBbss.bss\fR' symbols in the stabs themselves.  Having the linker
-relocate them there is no more work than having the linker relocate \s-1ELF\s0
-symbols, and it solves the problem of having to associate the \s-1ELF\s0 and
-stab symbols.  However, no one has yet designed or implemented such a
-scheme.
-.SS "Appendix G \s-1GNU\s0 Free Documentation License"
-.IX Subsection "Appendix G GNU Free Documentation License"
-Version 1.3, 3 November 2008
-.PP
-Copyright (C) 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc.
-`\fBhttp://fsf.org/\fR'
-.PP
-Everyone is permitted to copy and distribute verbatim copies
-of this license document, but changing it is not allowed.
-.PP
-0. \s-1PREAMBLE\s0
-.PP
-The purpose of this License is to make a manual, textbook, or other
-functional and useful document \*(L"free\*(R" in the sense of freedom: to
-assure everyone the effective freedom to copy and redistribute it,
-with or without modifying it, either commercially or
-noncommercially.  Secondarily, this License preserves for the
-author and publisher a way to get credit for their work, while not
-being considered responsible for modifications made by others.
-.PP
-This License is a kind of \*(L"copyleft\*(R", which means that derivative
-works of the document must themselves be free in the same sense.
-It complements the \s-1GNU\s0 General Public License, which is a copyleft
-license designed for free software.
-.PP
-We have designed this License in order to use it for manuals for
-free software, because free software needs free documentation: a
-free program should come with manuals providing the same freedoms
-that the software does.  But this License is not limited to
-software manuals; it can be used for any textual work, regardless
-of subject matter or whether it is published as a printed book.
-We recommend this License principally for works whose purpose is
-instruction or reference.
-.PP
-1. \s-1APPLICABILITY AND DEFINITIONS\s0
-.PP
-This License applies to any manual or other work, in any medium,
-that contains a notice placed by the copyright holder saying it
-can be distributed under the terms of this License.  Such a notice
-grants a world-wide, royalty-free license, unlimited in duration,
-to use that work under the conditions stated herein.  The
-\&\*(L"Document\*(R", below, refers to any such manual or work.  Any member
-of the public is a licensee, and is addressed as \*(L"you\*(R".  You
-accept the license if you copy, modify or distribute the work in a
-way requiring permission under copyright law.
-.PP
-A \*(L"Modified Version\*(R" of the Document means any work containing the
-Document or a portion of it, either copied verbatim, or with
-modifications and/or translated into another language.
-.PP
-A \*(L"Secondary Section\*(R" is a named appendix or a front-matter section
-of the Document that deals exclusively with the relationship of the
-publishers or authors of the Document to the Document's overall
-subject (or to related matters) and contains nothing that could
-fall directly within that overall subject.  (Thus, if the Document
-is in part a textbook of mathematics, a Secondary Section may not
-explain any mathematics.)  The relationship could be a matter of
-historical connection with the subject or with related matters, or
-of legal, commercial, philosophical, ethical or political position
-regarding them.
-.PP
-The \*(L"Invariant Sections\*(R" are certain Secondary Sections whose
-titles are designated, as being those of Invariant Sections, in
-the notice that says that the Document is released under this
-License.  If a section does not fit the above definition of
-Secondary then it is not allowed to be designated as Invariant.
-The Document may contain zero Invariant Sections.  If the Document
-does not identify any Invariant Sections then there are none.
-.PP
-The \*(L"Cover Texts\*(R" are certain short passages of text that are
-listed, as Front-Cover Texts or Back-Cover Texts, in the notice
-that says that the Document is released under this License.  A
-Front-Cover Text may be at most 5 words, and a Back-Cover Text may
-be at most 25 words.
-.PP
-A \*(L"Transparent\*(R" copy of the Document means a machine-readable copy,
-represented in a format whose specification is available to the
-general public, that is suitable for revising the document
-straightforwardly with generic text editors or (for images
-composed of pixels) generic paint programs or (for drawings) some
-widely available drawing editor, and that is suitable for input to
-text formatters or for automatic translation to a variety of
-formats suitable for input to text formatters.  A copy made in an
-otherwise Transparent file format whose markup, or absence of
-markup, has been arranged to thwart or discourage subsequent
-modification by readers is not Transparent.  An image format is
-not Transparent if used for any substantial amount of text.  A
-copy that is not \*(L"Transparent\*(R" is called \*(L"Opaque\*(R".
-.PP
-Examples of suitable formats for Transparent copies include plain
-\&\s-1ASCII\s0 without markup, Texinfo input format, LaTeX input format,
-\&\s-1SGML\s0 or \s-1XML\s0 using a publicly available \s-1DTD,\s0 and
-standard-conforming simple \s-1HTML,\s0 PostScript or \s-1PDF\s0 designed for
-human modification.  Examples of transparent image formats include
-\&\s-1PNG, XCF\s0 and \s-1JPG. \s0 Opaque formats include proprietary formats that
-can be read and edited only by proprietary word processors, \s-1SGML\s0 or
-\&\s-1XML\s0 for which the \s-1DTD\s0 and/or processing tools are not generally
-available, and the machine-generated \s-1HTML,\s0 PostScript or \s-1PDF\s0
-produced by some word processors for output purposes only.
-.PP
-The \*(L"Title Page\*(R" means, for a printed book, the title page itself,
-plus such following pages as are needed to hold, legibly, the
-material this License requires to appear in the title page.  For
-works in formats which do not have any title page as such, \*(L"Title
-Page\*(R" means the text near the most prominent appearance of the
-work's title, preceding the beginning of the body of the text.
-.PP
-The \*(L"publisher\*(R" means any person or entity that distributes copies
-of the Document to the public.
-.PP
-A section \*(L"Entitled \s-1XYZ\*(R"\s0 means a named subunit of the Document
-whose title either is precisely \s-1XYZ\s0 or contains \s-1XYZ\s0 in parentheses
-following text that translates \s-1XYZ\s0 in another language.  (Here \s-1XYZ\s0
-stands for a specific section name mentioned below, such as
-\&\*(L"Acknowledgements\*(R", \*(L"Dedications\*(R", \*(L"Endorsements\*(R", or \*(L"History\*(R".)
-To \*(L"Preserve the Title\*(R" of such a section when you modify the
-Document means that it remains a section \*(L"Entitled \s-1XYZ\*(R"\s0 according
-to this definition.
-.PP
-The Document may include Warranty Disclaimers next to the notice
-which states that this License applies to the Document.  These
-Warranty Disclaimers are considered to be included by reference in
-this License, but only as regards disclaiming warranties: any other
-implication that these Warranty Disclaimers may have is void and
-has no effect on the meaning of this License.
-.PP
-2. \s-1VERBATIM COPYING\s0
-.PP
-You may copy and distribute the Document in any medium, either
-commercially or noncommercially, provided that this License, the
-copyright notices, and the license notice saying this License
-applies to the Document are reproduced in all copies, and that you
-add no other conditions whatsoever to those of this License.  You
-may not use technical measures to obstruct or control the reading
-or further copying of the copies you make or distribute.  However,
-you may accept compensation in exchange for copies.  If you
-distribute a large enough number of copies you must also follow
-the conditions in section 3.
-.PP
-You may also lend copies, under the same conditions stated above,
-and you may publicly display copies.
-.PP
-3. \s-1COPYING IN QUANTITY\s0
-.PP
-If you publish printed copies (or copies in media that commonly
-have printed covers) of the Document, numbering more than 100, and
-the Document's license notice requires Cover Texts, you must
-enclose the copies in covers that carry, clearly and legibly, all
-these Cover Texts: Front-Cover Texts on the front cover, and
-Back-Cover Texts on the back cover.  Both covers must also clearly
-and legibly identify you as the publisher of these copies.  The
-front cover must present the full title with all words of the
-title equally prominent and visible.  You may add other material
-on the covers in addition.  Copying with changes limited to the
-covers, as long as they preserve the title of the Document and
-satisfy these conditions, can be treated as verbatim copying in
-other respects.
-.PP
-If the required texts for either cover are too voluminous to fit
-legibly, you should put the first ones listed (as many as fit
-reasonably) on the actual cover, and continue the rest onto
-adjacent pages.
-.PP
-If you publish or distribute Opaque copies of the Document
-numbering more than 100, you must either include a
-machine-readable Transparent copy along with each Opaque copy, or
-state in or with each Opaque copy a computer-network location from
-which the general network-using public has access to download
-using public-standard network protocols a complete Transparent
-copy of the Document, free of added material.  If you use the
-latter option, you must take reasonably prudent steps, when you
-begin distribution of Opaque copies in quantity, to ensure that
-this Transparent copy will remain thus accessible at the stated
-location until at least one year after the last time you
-distribute an Opaque copy (directly or through your agents or
-retailers) of that edition to the public.
-.PP
-It is requested, but not required, that you contact the authors of
-the Document well before redistributing any large number of
-copies, to give them a chance to provide you with an updated
-version of the Document.
-.PP
-4. \s-1MODIFICATIONS\s0
-.PP
-You may copy and distribute a Modified Version of the Document
-under the conditions of sections 2 and 3 above, provided that you
-release the Modified Version under precisely this License, with
-the Modified Version filling the role of the Document, thus
-licensing distribution and modification of the Modified Version to
-whoever possesses a copy of it.  In addition, you must do these
-things in the Modified Version:
-.PP
-A. Use in the Title Page (and on the covers, if any) a title
-distinct from that of the Document, and from those of
-previous versions (which should, if there were any, be listed
-in the History section of the Document).  You may use the
-same title as a previous version if the original publisher of
-that version gives permission.
-.PP
-B. List on the Title Page, as authors, one or more persons or
-entities responsible for authorship of the modifications in
-the Modified Version, together with at least five of the
-principal authors of the Document (all of its principal
-authors, if it has fewer than five), unless they release you
-from this requirement.
-.PP
-C. State on the Title page the name of the publisher of the
-Modified Version, as the publisher.
-.PP
-D. Preserve all the copyright notices of the Document.
-.PP
-E. Add an appropriate copyright notice for your modifications
-adjacent to the other copyright notices.
-.PP
-F. Include, immediately after the copyright notices, a license
-notice giving the public permission to use the Modified
-Version under the terms of this License, in the form shown in
-the Addendum below.
-.PP
-G. Preserve in that license notice the full lists of Invariant
-Sections and required Cover Texts given in the Document's
-license notice.
-.PP
-H. Include an unaltered copy of this License.
-.PP
-I. Preserve the section Entitled \*(L"History\*(R", Preserve its Title,
-and add to it an item stating at least the title, year, new
-authors, and publisher of the Modified Version as given on
-the Title Page.  If there is no section Entitled \*(L"History\*(R" in
-the Document, create one stating the title, year, authors,
-and publisher of the Document as given on its Title Page,
-then add an item describing the Modified Version as stated in
-the previous sentence.
-.PP
-J. Preserve the network location, if any, given in the Document
-for public access to a Transparent copy of the Document, and
-likewise the network locations given in the Document for
-previous versions it was based on.  These may be placed in
-the \*(L"History\*(R" section.  You may omit a network location for a
-work that was published at least four years before the
-Document itself, or if the original publisher of the version
-it refers to gives permission.
-.PP
-K. For any section Entitled \*(L"Acknowledgements\*(R" or \*(L"Dedications\*(R",
-Preserve the Title of the section, and preserve in the
-section all the substance and tone of each of the contributor
-acknowledgements and/or dedications given therein.
-.PP
-L. Preserve all the Invariant Sections of the Document,
-unaltered in their text and in their titles.  Section numbers
-or the equivalent are not considered part of the section
-titles.
-.PP
-M. Delete any section Entitled \*(L"Endorsements\*(R".  Such a section
-may not be included in the Modified Version.
-.PP
-N. Do not retitle any existing section to be Entitled
-\&\*(L"Endorsements\*(R" or to conflict in title with any Invariant
-Section.
-.PP
-O. Preserve any Warranty Disclaimers.
-.PP
-If the Modified Version includes new front-matter sections or
-appendices that qualify as Secondary Sections and contain no
-material copied from the Document, you may at your option
-designate some or all of these sections as invariant.  To do this,
-add their titles to the list of Invariant Sections in the Modified
-Version's license notice.  These titles must be distinct from any
-other section titles.
-.PP
-You may add a section Entitled \*(L"Endorsements\*(R", provided it contains
-nothing but endorsements of your Modified Version by various
-parties\*(--for example, statements of peer review or that the text
-has been approved by an organization as the authoritative
-definition of a standard.
-.PP
-You may add a passage of up to five words as a Front-Cover Text,
-and a passage of up to 25 words as a Back-Cover Text, to the end
-of the list of Cover Texts in the Modified Version.  Only one
-passage of Front-Cover Text and one of Back-Cover Text may be
-added by (or through arrangements made by) any one entity.  If the
-Document already includes a cover text for the same cover,
-previously added by you or by arrangement made by the same entity
-you are acting on behalf of, you may not add another; but you may
-replace the old one, on explicit permission from the previous
-publisher that added the old one.
-.PP
-The author(s) and publisher(s) of the Document do not by this
-License give permission to use their names for publicity for or to
-assert or imply endorsement of any Modified Version.
-.PP
-5. \s-1COMBINING DOCUMENTS\s0
-.PP
-You may combine the Document with other documents released under
-this License, under the terms defined in section 4 above for
-modified versions, provided that you include in the combination
-all of the Invariant Sections of all of the original documents,
-unmodified, and list them all as Invariant Sections of your
-combined work in its license notice, and that you preserve all
-their Warranty Disclaimers.
-.PP
-The combined work need only contain one copy of this License, and
-multiple identical Invariant Sections may be replaced with a single
-copy.  If there are multiple Invariant Sections with the same name
-but different contents, make the title of each such section unique
-by adding at the end of it, in parentheses, the name of the
-original author or publisher of that section if known, or else a
-unique number.  Make the same adjustment to the section titles in
-the list of Invariant Sections in the license notice of the
-combined work.
-.PP
-In the combination, you must combine any sections Entitled
-\&\*(L"History\*(R" in the various original documents, forming one section
-Entitled \*(L"History\*(R"; likewise combine any sections Entitled
-\&\*(L"Acknowledgements\*(R", and any sections Entitled \*(L"Dedications\*(R".  You
-must delete all sections Entitled \*(L"Endorsements.\*(R"
-.PP
-6. \s-1COLLECTIONS OF DOCUMENTS\s0
-.PP
-You may make a collection consisting of the Document and other
-documents released under this License, and replace the individual
-copies of this License in the various documents with a single copy
-that is included in the collection, provided that you follow the
-rules of this License for verbatim copying of each of the
-documents in all other respects.
-.PP
-You may extract a single document from such a collection, and
-distribute it individually under this License, provided you insert
-a copy of this License into the extracted document, and follow
-this License in all other respects regarding verbatim copying of
-that document.
-.PP
-7. \s-1AGGREGATION WITH INDEPENDENT WORKS\s0
-.PP
-A compilation of the Document or its derivatives with other
-separate and independent documents or works, in or on a volume of
-a storage or distribution medium, is called an \*(L"aggregate\*(R" if the
-copyright resulting from the compilation is not used to limit the
-legal rights of the compilation's users beyond what the individual
-works permit.  When the Document is included in an aggregate, this
-License does not apply to the other works in the aggregate which
-are not themselves derivative works of the Document.
-.PP
-If the Cover Text requirement of section 3 is applicable to these
-copies of the Document, then if the Document is less than one half
-of the entire aggregate, the Document's Cover Texts may be placed
-on covers that bracket the Document within the aggregate, or the
-electronic equivalent of covers if the Document is in electronic
-form.  Otherwise they must appear on printed covers that bracket
-the whole aggregate.
-.PP
-8. \s-1TRANSLATION\s0
-.PP
-Translation is considered a kind of modification, so you may
-distribute translations of the Document under the terms of section
-4.  Replacing Invariant Sections with translations requires special
-permission from their copyright holders, but you may include
-translations of some or all Invariant Sections in addition to the
-original versions of these Invariant Sections.  You may include a
-translation of this License, and all the license notices in the
-Document, and any Warranty Disclaimers, provided that you also
-include the original English version of this License and the
-original versions of those notices and disclaimers.  In case of a
-disagreement between the translation and the original version of
-this License or a notice or disclaimer, the original version will
-prevail.
-.PP
-If a section in the Document is Entitled \*(L"Acknowledgements\*(R",
-\&\*(L"Dedications\*(R", or \*(L"History\*(R", the requirement (section 4) to
-Preserve its Title (section 1) will typically require changing the
-actual title.
-.PP
-9. \s-1TERMINATION\s0
-.PP
-You may not copy, modify, sublicense, or distribute the Document
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense, or distribute it is void,
-and will automatically terminate your rights under this License.
-.PP
-However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly
-and finally terminates your license, and (b) permanently, if the
-copyright holder fails to notify you of the violation by some
-reasonable means prior to 60 days after the cessation.
-.PP
-Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from
-that copyright holder, and you cure the violation prior to 30 days
-after your receipt of the notice.
-.PP
-Termination of your rights under this section does not terminate
-the licenses of parties who have received copies or rights from
-you under this License.  If your rights have been terminated and
-not permanently reinstated, receipt of a copy of some or all of
-the same material does not give you any rights to use it.
-.PP
-10. \s-1FUTURE REVISIONS OF THIS LICENSE\s0
-.PP
-The Free Software Foundation may publish new, revised versions of
-the \s-1GNU\s0 Free Documentation License from time to time.  Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.  See
-`\fBhttp://www.gnu.org/copyleft/\fR'.
-.PP
-Each version of the License is given a distinguishing version
-number.  If the Document specifies that a particular numbered
-version of this License \*(L"or any later version\*(R" applies to it, you
-have the option of following the terms and conditions either of
-that specified version or of any later version that has been
-published (not as a draft) by the Free Software Foundation.  If
-the Document does not specify a version number of this License,
-you may choose any version ever published (not as a draft) by the
-Free Software Foundation.  If the Document specifies that a proxy
-can decide which future versions of this License can be used, that
-proxy's public statement of acceptance of a version permanently
-authorizes you to choose that version for the Document.
-.PP
-11. \s-1RELICENSING\s0
-.PP
-\&\*(L"Massive Multiauthor Collaboration Site\*(R" (or \*(L"\s-1MMC\s0 Site\*(R") means any
-World Wide Web server that publishes copyrightable works and also
-provides prominent facilities for anybody to edit those works.  A
-public wiki that anybody can edit is an example of such a server.
-A \*(L"Massive Multiauthor Collaboration\*(R" (or \*(L"\s-1MMC\*(R"\s0) contained in the
-site means any set of copyrightable works thus published on the \s-1MMC\s0
-site.
-.PP
-\&\*(L"CC-BY-SA\*(R" means the Creative Commons Attribution-Share Alike 3.0
-license published by Creative Commons Corporation, a not-for-profit
-corporation with a principal place of business in San Francisco,
-California, as well as future copyleft versions of that license
-published by that same organization.
-.PP
-\&\*(L"Incorporate\*(R" means to publish or republish a Document, in whole or
-in part, as part of another Document.
-.PP
-An \s-1MMC\s0 is \*(L"eligible for relicensing\*(R" if it is licensed under this
-License, and if all works that were first published under this
-License somewhere other than this \s-1MMC,\s0 and subsequently
-incorporated in whole or in part into the \s-1MMC, \\fIs0\fR\|(1) had no cover
-texts or invariant sections, and (2) were thus incorporated prior
-to November 1, 2008.
-.PP
-The operator of an \s-1MMC\s0 Site may republish an \s-1MMC\s0 contained in the
-site under CC-BY-SA on the same site at any time before August 1,
-2009, provided the \s-1MMC\s0 is eligible for relicensing.
-.PP
-\&\s-1ADDENDUM:\s0 How to use this License for your documents
-====================================================
-.PP
-To use this License in a document you have written, include a copy of
-the License in the document and put the following copyright and license
-notices just after the title page:
-.PP
-Copyright (C)  \s-1YEAR  YOUR NAME.\s0
-Permission is granted to copy, distribute and/or modify this document
-under the terms of the \s-1GNU\s0 Free Documentation License, Version 1.3
-or any later version published by the Free Software Foundation;
-with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
-Texts.  A copy of the license is included in the section entitled ``\s-1GNU\s0
-Free Documentation License''.
-.PP
-If you have Invariant Sections, Front-Cover Texts and Back-Cover
-Texts, replace the \*(L"with...Texts.\*(R" line with this:
-.PP
-with the Invariant Sections being \s-1LIST THEIR TITLES,\s0 with
-the Front-Cover Texts being \s-1LIST,\s0 and with the Back-Cover Texts
-being \s-1LIST.\s0
-.PP
-If you have Invariant Sections without Cover Texts, or some other
-combination of the three, merge those two alternatives to suit the
-situation.
-.PP
-If your document contains nontrivial examples of program code, we
-recommend releasing these examples in parallel under your choice of
-free software license, such as the \s-1GNU\s0 General Public License, to
-permit their use in free software.
-.SS "Symbol Types Index"
-.IX Subsection "Symbol Types Index"
-\0\b[index\0\b]
-* Menu:
-.PP
-\&.bb: see \*(L"Block Structure\*(R", .      (line 26)
-.PP
-\&.be: see \*(L"Block Structure\*(R", .      (line 26)
-.PP
-C_BCOMM: see \*(L"Common Blocks\*(R", .        (line 10)
-.PP
-C_BINCL: see \*(L"Include Files\*(R", .        (line 41)
-.PP
-C_BLOCK: see \*(L"Block Structure\*(R", .      (line 26)
-.PP
-C_BSTAT: see \*(L"Statics\*(R", .              (line 31)
-.PP
-C_DECL, for types: see \*(L"Typedefs\*(R", .             (line  6)
-.PP
-C_ECOML: see \*(L"Common Blocks\*(R", .        (line 17)
-.PP
-C_ECOMM: see \*(L"Common Blocks\*(R", .        (line 10)
-.PP
-C_EINCL: see \*(L"Include Files\*(R", .        (line 41)
-.PP
-C_ENTRY: see \*(L"Alternate Entry Points\*(R", .
-.PP
-(line  6)
-C_ESTAT: see \*(L"Statics\*(R", .              (line 31)
-.PP
-C_FILE: see \*(L"Source Files\*(R", .         (line 61)
-.PP
-C_FUN: see \*(L"Procedures\*(R", .           (line 18)
-.PP
-C_GSYM: see \*(L"Global Variables\*(R", .     (line  6)
-.PP
-C_LSYM: see \*(L"Stack Variables\*(R", .      (line 11)
-.PP
-C_PSYM: see \*(L"Parameters\*(R", .           (line 12)
-.PP
-C_RPSYM: see \*(L"Register Parameters\*(R", .  (line 15)
-.PP
-C_RSYM: see \*(L"Register Variables\*(R", .   (line  6)
-.PP
-C_STSYM: see \*(L"Statics\*(R", .              (line 31)
-.PP
-N_BCOMM: see \*(L"Common Blocks\*(R", .        (line 10)
-.PP
-N_BINCL: see \*(L"Include Files\*(R", .        (line 17)
-.PP
-N_BROWS: see \*(L"N_BROWS\*(R", .              (line  7)
-.PP
-N_BSLINE: see \*(L"Line Numbers\*(R", .         (line 12)
-.PP
-N_CATCH: see \*(L"N_CATCH\*(R", .              (line  7)
-.PP
-N_DEFD: see \*(L"N_DEFD\*(R", .               (line  7)
-.PP
-N_DSLINE: see \*(L"Line Numbers\*(R", .         (line 12)
-.PP
-N_ECOML: see \*(L"Common Blocks\*(R", .        (line 17)
-.PP
-N_ECOMM: see \*(L"Common Blocks\*(R", .        (line 10)
-.PP
-N_EHDECL: see \*(L"N_EHDECL\*(R", .             (line  7)
-.PP
-N_EINCL: see \*(L"Include Files\*(R", .        (line 17)
-.PP
-N_ENTRY: see \*(L"Alternate Entry Points\*(R", .
-.PP
-(line  6)
-N_EXCL: see \*(L"Include Files\*(R", .        (line 17)
-.PP
-N_FNAME: see \*(L"Procedures\*(R", .           (line  6)
-.PP
-N_FUN, for functions: see \*(L"Procedures\*(R", .           (line  6)
-.PP
-N_FUN, for variables: see \*(L"Statics\*(R", .              (line 12)
-.PP
-N_GSYM: see \*(L"Global Variables\*(R", .     (line  6)
-.PP
-N_GSYM, for functions (Sun acc): see \*(L"Procedures\*(R", .           (line  6)
-.PP
-N_LBRAC: see \*(L"Block Structure\*(R", .      (line  6)
-.PP
-N_LCSYM: see \*(L"Statics\*(R", .              (line 12)
-.PP
-N_LENG: see \*(L"N_LENG\*(R", .               (line  7)
-.PP
-N_LSYM, for parameter: see \*(L"Local Variable Parameters\*(R", .
-.PP
-(line 35)
-N_LSYM, for stack variables: see \*(L"Stack Variables\*(R", .      (line 11)
-.PP
-N_LSYM, for types: see \*(L"Typedefs\*(R", .             (line  6)
-.PP
-N_M2C: see \*(L"N_M2C\*(R", .                (line  7)
-.PP
-N_MAC_DEFINE: see \*(L"Macro define and undefine\*(R", .
-.PP
-(line 11)
-N_MAC_UNDEF: see \*(L"Macro define and undefine\*(R", .
-.PP
-(line 14)
-N_MAIN: see \*(L"Main Program\*(R", .         (line  6)
-.PP
-N_MOD2: see \*(L"N_MOD2\*(R", .               (line  7)
-.PP
-N_NBBSS: see \*(L"Gould\*(R", .                (line  9)
-.PP
-N_NBDATA: see \*(L"Gould\*(R", .                (line  8)
-.PP
-N_NBLCS: see \*(L"Gould\*(R", .                (line 11)
-.PP
-N_NBSTS: see \*(L"Gould\*(R", .                (line 10)
-.PP
-N_NBTEXT: see \*(L"Gould\*(R", .                (line  7)
-.PP
-N_NOMAP: see \*(L"N_NOMAP\*(R", .              (line  7)
-.PP
-N_NSYMS: see \*(L"N_NSYMS\*(R", .              (line  7)
-.PP
-N_PC: see \*(L"N_PC\*(R", .                 (line  7)
-.PP
-N_PSYM: see \*(L"Parameters\*(R", .           (line 12)
-.PP
-N_RBRAC: see \*(L"Block Structure\*(R", .      (line  6)
-.PP
-N_ROSYM: see \*(L"Statics\*(R", .              (line 12)
-.PP
-N_RSYM: see \*(L"Register Variables\*(R", .   (line  6)
-.PP
-N_RSYM, for parameters: see \*(L"Register Parameters\*(R", .  (line 15)
-.PP
-N_SCOPE: see \*(L"N_SCOPE\*(R", .              (line  7)
-.PP
-N_SLINE: see \*(L"Line Numbers\*(R", .         (line  6)
-.PP
-N_SO: see \*(L"Source Files\*(R", .         (line  6)
-.PP
-N_SOL: see \*(L"Include Files\*(R", .        (line 11)
-.PP
-N_SSYM: see \*(L"N_SSYM\*(R", .               (line  7)
-.PP
-N_STSYM: see \*(L"Statics\*(R", .              (line 12)
-.PP
-N_STSYM, for functions (Sun acc): see \*(L"Procedures\*(R", .           (line  6)