From 139741da175026d0889ffbbae3a758c5bc6642c1 Mon Sep 17 00:00:00 2001 From: Roland Pesch Date: Wed, 2 Sep 1992 04:08:28 +0000 Subject: [PATCH] Formatting improvements and other minor edits. --- gdb/doc/stabs.texinfo | 1480 +++++++++++++++++++++++------------------ 1 file changed, 829 insertions(+), 651 deletions(-) diff --git a/gdb/doc/stabs.texinfo b/gdb/doc/stabs.texinfo index 208457f8410..bddb1c484bb 100644 --- a/gdb/doc/stabs.texinfo +++ b/gdb/doc/stabs.texinfo @@ -4,7 +4,7 @@ @ifinfo @format START-INFO-DIR-ENTRY -* Stabs: (stabs). The "stabs" debugging information format. +* Stabs: (stabs). The "stabs" debugging information format. END-INFO-DIR-ENTRY @end format @end ifinfo @@ -31,10 +31,10 @@ manual under the terms of the GPL (for which purpose this text may be regarded as a program in the language TeX). @end ifinfo -@setchapternewpage off +@setchapternewpage odd @settitle STABS @titlepage -@title{The "stabs" representation of debugging information.} +@title The ``stabs'' debug format @author Julia Menapace @author Cygnus Support @page @@ -65,25 +65,25 @@ are preserved on all copies. This document describes the GNU stabs debugging format in a.out files. @menu -* Overview:: Overview of stabs -* Program structure:: Encoding of the structure of the program +* Overview:: Overview of stabs +* Program structure:: Encoding of the structure of the program * Simple types:: -* Example:: A comprehensive example in C +* Example:: A comprehensive example in C * Variables:: * Aggregate types:: -* Symbol tables:: Symbol information in symbol tables +* Symbol tables:: Symbol information in symbol tables * GNU C++ stabs:: Appendixes: -* Example2.c:: Source code for extended example -* Example2.s:: Assembly code for extended example -* Quick reference:: Various refernce tables -* Expanded reference:: Reference information by stab type -* Questions:: Questions and anomolies -* xcoff-differences:: Differences between GNU stabs in a.out - and GNU stabs in xcoff -* Sun-differences:: Differences between GNU stabs and Sun - native stabs +* Example2.c:: Source code for extended example +* Example2.s:: Assembly code for extended example +* Quick reference:: Various refernce tables +* Expanded reference:: Reference information by stab type +* Questions:: Questions and anomolies +* xcoff-differences:: Differences between GNU stabs in a.out + and GNU stabs in xcoff +* Sun-differences:: Differences between GNU stabs and Sun + native stabs @end menu @end ifinfo @@ -91,6 +91,12 @@ Appendixes: @node Overview @chapter Overview of stabs +@dfn{Stabs} refers to a format for information that describes a program +to a debugger. This format was apparently invented by +@c FIXME! <> at +the University of California at Berkeley, for the @code{pdx} Pascal +debugger; the format has spread widely since then. + @menu * Flow:: Overview of debugging information flow * Stabs format:: Overview of stab format @@ -101,108 +107,117 @@ Appendixes: @node Flow @section Overview of debugging information flow -GCC compiles C source in a .c file into assembly language in a .s -file, which is translated by the assembler into a .o file, and then -linked with other .o files and libraries to produce an executable -file. +The GNU C compiler compiles C source in a @file{.c} file into assembly +language in a @file{.s} file, which is translated by the assembler into +a @file{.o} file, and then linked with other @file{.o} files and +libraries to produce an executable file. -When using the -g option, GCC puts additional debugging information in -the .s file, which is slightly transformed by the assembler and +With the @samp{-g} option, GCC puts additional debugging information in +the @file{.s} file, 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 functions, their parameters and their scopes. For some object file formats, the debugging information is -encapsulated in pseudo-ops to the assembler known as `stab' (symbol +encapsulated in assembler directives known collectively as `stab' (symbol table) directives, interspersed with the generated code. Stabs are the native format for debugging information in the a.out and xcoff object file formats. The GNU tools can also emit stabs in the coff and ecoff object file formats. -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 .o file it is building. The linker consolidates the .o -files into one executable file, with one symbol and one string table. -Debuggers use the symbol and string tables in the executable as a -source of debugging information about the program. +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 +@file{.o} file it is building. The linker consolidates the @file{.o} +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. @node Stabs format @section Overview of stab format There are three overall formats for stab assembler directives -differentiated by the first word of the stab. The first word -describes what combination of four possible data fields will follow. -It is either .stabs (string), .stabn (number), or .stabd (dot). +differentiated by the first word of the stab. The name of the directive +describes what combination of four possible data fields will follow. It +is either @code{.stabs} (string), @code{.stabn} (number), or +@code{.stabd} (dot). The overall format of each class of stab is: @example -.stabs "string",type,0,desc,value -.stabn type,0,desc,value -.stabd type,0,desc +.stabs "@var{string}",@var{type},0,@var{desc},@var{value} +.stabn @var{type},0,@var{desc},@var{value} +.stabd @var{type},0,@var{desc} @end example -In general, in .stabs the string field contains name and type -information. For .stabd the value field is implicit and has the value +In general, in @code{.stabs} the @var{string} field contains name and type +information. For @code{.stabd} the value field is implicit and has the value of the current file location. Otherwise the value field often contains a relocatable address, frame pointer offset, or register number, that maps to the source code element described by the stab. -The real key to decoding the meaning of a stab is the number in its -type field. Each possible type number defines a different stab type. -The stab type further defines the exact interpretation of, and -possible values for, any remaining "string", desc, or value fields -present in the stab. Table A lists in numeric order the possible type -field values for stab directives. The reference section that follows -Table A describes the meaning of the fields for each stab type in -detail. The examples that follow this overview introduce the stab -types in terms of the source code elements they describe. +The real key to decoding the meaning of a stab is the number in its type +field. Each possible type number defines a different stab type. The +stab type further defines the exact interpretation of, and possible +values for, any remaining @code{"@var{string}"}, @var{desc}, or +@var{value} fields present in the stab. Table A (@pxref{Stab +types,,Table A: Symbol types from stabs}) lists in numeric order +the possible type field values for stab directives. The reference +section that follows Table A describes the meaning of the fields for +each stab type in detail. The examples that follow this overview +introduce the stab types in terms of the source code elements they +describe. -For .stabs the "string" field holds the meat of the debugging -information. The generally unstructured 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. +For @code{.stabs} the @code{"@var{string}"} field holds the meat of the +debugging information. The generally unstructured 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. -The overall format is of the "string" field is: +The overall format is of the @code{"@var{string}"} field is: @example -"name[:symbol_descriptor][type_number[=type_descriptor...]]" +"@var{name}@r{[}:@var{symbol_descriptor}@r{]} + @r{[}@var{type_number}@r{[}=@var{type_descriptor} @r{@dots{}]]}" @end example -name is the name of the symbol represented by the stab. +@var{name} is the name of the symbol represented by the stab. -The symbol_descriptor following the : 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. See Table C for a list of -symbol_descriptors. +The @var{symbol_descriptor} following the @samp{:} is an alphabetic +character that tells more specifically what kind of symbol the stab +represents. If the @var{symbol_descriptor} is omitted, but type +information follows, then the stab represents a local variable. For a +list of symbol_descriptors, see @ref{Symbol descriptors,,Table C: Symbol +descriptors}. -Type information it is either a type_number, or a type_number=. The -type_number alone is a type reference, referring directly to a type -that has already been defined. +Type information is either a @var{type_number}, or a +@samp{@var{type_number}=}. The @var{type_number} alone is a type +reference, referring directly to a type that has already been defined. -The type_number= 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 = -and nested definitions. +The @samp{@var{type_number}=} 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 @samp{=} and nested definitions. 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. If a number -follows the = then the number is a type_reference. This is described -more thoroughly in the section on types. See Table D for a list of -type_descriptors. - -All this can make the "string" field quite long. When the "string" -part of a stab is more than 80 characters, we split the .stabs -pseudo-op into two .stabs pseudo-ops, both stabs duplicate exactly all -but the "string" field. The "string" field of the first stab contains -the first part of the overlong string, marked as continued with a -double-backslash at the end. The "string" field of the second stab -holds the second half of the overlong string. +non-numeric then it is a @var{type_descriptor}, and tells what kind of +type is about to be defined. Any other values following the +@var{type_descriptor} vary, depending on the @var{type_descriptor}. If +a number follows the @samp{=} then the number is a @var{type_reference}. +This is described more thoroughly in the section on types. @xref{Type +Descriptors,,Table D: Type Descriptors}, for a list of +@var{type_descriptor} values. + +@c FIXME! "too long" below introduced at J Gilmore's request; used to +@c say "more than 80 chars". Why is vaguer better? +All this can make the @code{"@var{string}"} field quite long. When the +@code{"@var{string}"} part of a stab is too long, the compiler splits +the @code{.stabs} directive into two @code{.stabs} directives. Both +stabs duplicate exactly all but the @code{"@var{string}"} field. The +@code{"@var{string}"} field of the first stab contains the first part of +the overlong string, marked as continued with a double-backslash at the +end. The @code{"@var{string}"} field of the second stab holds the +second half of the overlong string. @node C example @section A simple example in C source @@ -213,13 +228,14 @@ program, let's look at the simple program: @example main() @{ - printf("Hello world"); + printf("Hello world"); @} @end example -When compiled with -g, the program above yields the following .s file. -Line numbers have been added so it will be easier to refer to parts of -the .s file in the description of the stabs that follows. +When compiled with @samp{-g}, the program above yields the following +@file{.s} file. Line numbers have been added to make it easier to refer +to parts of the @file{.s} file in the description of the stabs that +follows. @node Assembly code @section The simple example at the assembly level @@ -245,45 +261,45 @@ the .s file in the description of the stabs that follows. 18 .stabs "double:t13=r1;8;0;",128,0,0,0 19 .stabs "long double:t14=r1;8;0;",128,0,0,0 20 .stabs "void:t15=15",128,0,0,0 -21 .align 4 +21 .align 4 22 LC0: -23 .ascii "Hello, world!\12\0" -24 .align 4 -25 .global _main -26 .proc 1 +23 .ascii "Hello, world!\12\0" +24 .align 4 +25 .global _main +26 .proc 1 27 _main: 28 .stabn 68,0,4,LM1 29 LM1: -30 !#PROLOGUE# 0 -31 save %sp,-136,%sp -32 !#PROLOGUE# 1 -33 call ___main,0 -34 nop +30 !#PROLOGUE# 0 +31 save %sp,-136,%sp +32 !#PROLOGUE# 1 +33 call ___main,0 +34 nop 35 .stabn 68,0,5,LM2 36 LM2: 37 LBB2: -38 sethi %hi(LC0),%o1 -39 or %o1,%lo(LC0),%o0 -40 call _printf,0 -41 nop +38 sethi %hi(LC0),%o1 +39 or %o1,%lo(LC0),%o0 +40 call _printf,0 +41 nop 42 .stabn 68,0,6,LM3 43 LM3: 44 LBE2: 45 .stabn 68,0,6,LM4 46 LM4: 47 L1: -48 ret -49 restore +48 ret +49 restore 50 .stabs "main:F1",36,0,0,_main 51 .stabn 192,0,0,LBB2 52 .stabn 224,0,0,LBE2 @end example -This simple hello world example, demonstrates several of the stab +This simple ``hello world'' example demonstrates several of the stab types used to describe C language source files. @node Program structure -@chapter Encoding of the structure of the program +@chapter Encoding for the structure of the program @menu * Source file:: The path and name of the source file @@ -295,9 +311,12 @@ types used to describe C language source files. @node Source file @section The path and name of the source file -@example -.stabs, stab type N_SO -@end example +@table @strong +@item Directive: +@code{.stabs} +@item Type: +@code{N_SO} +@end table The first stabs in the .s file contain the name and path of the source file that was compiled to produce the .s file. This information is @@ -311,58 +330,78 @@ contained in two records of stab type N_SO (100). @example 2 .stabs "/cygint/s1/users/jcm/play/",100,0,0,Ltext0 3 .stabs "hello.c",100,0,0,Ltext0 -4 .text +4 .text 5 Ltext0: @end example @node Line numbers @section Line Numbers -@example -.stabn, stab type N_SLINE -@end example +@table @strong +@item Directive: +@code{.stabn} +@item Type: +@code{N_SLINE} +@end table -The start of source lines is represented by the N_SLINE (68) stab +The start of source lines is represented by the @code{N_SLINE} (68) stab type. @example - .stabn N_SLINE, NIL, source_line_number, - code_address_for_start_of_source_line +.stabn N_SLINE, NIL, @var{line}, @var{address} @end example +@var{line} is a source line number; @var{address} represents the code +address for the start of that source line. + @example 27 _main: 28 .stabn 68,0,4,LM1 29 LM1: -30 !#PROLOGUE# 0 +30 !#PROLOGUE# 0 @end example @node Procedures @section Procedures -@example -.stabs, stab type N_FUN, - symbol descriptors f (local), F (global) -@end example +@table @strong +@item Directive: +@code{.stabs} +@item Type: +@code{N_FUN} +@item Symbol Descriptors: +@code{f} (local), @code{F} (global) +@end table -Procedures are described by the N_FUN stab type. The symbol -descriptor for a procedure is F if the proc is globally scoped and f -if the procedure is static (locally scoped). +Procedures are described by the @code{N_FUN} stab type. The symbol +descriptor for a procedure is @samp{F} if the procedure is globally +scoped and @samp{f} if the procedure is static (locally scoped). -The N_FUN stab representing a procedure is located immediatly -following the code of the procedure. The N_FUN stab is in turn +The @code{N_FUN} stab representing a procedure is located immediately +following the code of the procedure. The @code{N_FUN} 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. @example -48 ret -49 restore +48 ret +49 restore @end example +The @code{.stabs} entry after this code fragment shows the @var{name} of +the procedure (@code{main}); the type descriptor @var{desc} (@code{F}, +for a global procedure); a reference to the predefined type @code{int} +for the return type; and the starting @var{address} of the procedure. + +Here is an exploded summary (with whitespace introduced for clarity), +followed by line 50 of our sample assembly output, which has this form: + @example - .stabs "procedure_name:symbol_desc(global proc)return_type_ref(int)", - N_FUN, NIL, NIL, Code_address_of_procedure_start +.stabs "@var{name}: + @var{desc} @r{(global proc @samp{F})} + @var{return_type_ref} @r{(int)} + ",N_FUN, NIL, NIL, + @var{address} @end example @example @@ -372,38 +411,42 @@ block local variables and its block structure. @node Block Structure @section Block Structure -@example -.stabn, stab types N_LBRAC, N_RRAC -@end example +@table @strong +@item Directive: +@code{.stabn} +@item Types: +@code{N_LBRAC}, @code{N_RBRAC} +@end table -The program's block structure is represented by the N_LBRAC (left -brace) and the N_RBRAC (right brace) stab types. The following code -range, which is the body of main, is labeled with LBB2: at the -beginning and LBE2: at the end. +The program's block structure is represented by the @code{N_LBRAC} (left +brace) and the @code{N_RBRAC} (right brace) stab types. The following code +range, which is the body of @code{main}, is labeled with @samp{LBB2:} at the +beginning and @samp{LBE2:} at the end. @example 37 LBB2: -38 sethi %hi(LC0),%o1 -39 or %o1,%lo(LC0),%o0 -40 call _printf,0 -41 nop +38 sethi %hi(LC0),%o1 +39 or %o1,%lo(LC0),%o0 +40 call _printf,0 +41 nop 42 .stabn 68,0,6,LM3 43 LM3: 44 LBE2: @end example -The N_LBRAC and N_RBRAC stabs that describe the block scope of the -procedure are located after the N_FUNC stab that represents the -procedure itself. The N_LBRAC uses the LBB2 label as the code address -in its value field and the N_RBRAC uses the LBE2. +The @code{N_LBRAC} and @code{N_RBRAC} stabs that describe the block +scope of the procedure are located after the @code{N_FUNC} stab that +represents the procedure itself. The @code{N_LBRAC} uses the +@code{LBB2} label as the code address in its value field, and the +@code{N_RBRAC} uses @code{LBE2}. @example 50 .stabs "main:F1",36,0,0,_main @end example @example - .stabn N_LBRAC, NIL, NIL, Code_Address_for_left_brace - .stabn N_RBRAC, NIL, NIL, Code_Address_for_right_brace + .stabn N_LBRAC, NIL, NIL, @var{left-brace-address} + .stabn N_RBRAC, NIL, NIL, @var{right-brace-address} @end example @example @@ -415,7 +458,7 @@ in its value field and the N_RBRAC uses the LBE2. @chapter Simple types @menu -* Basic types:: +* Basic types:: Basic type definitions * Range types:: Range types defined by min and max value * Bit-ranges:: Range type defined by number of bits @end menu @@ -423,12 +466,16 @@ in its value field and the N_RBRAC uses the LBE2. @node Basic types @section Basic type definitions -@example -.stabs, stab type N_LSYM, - symbol descriptor t -@end example +@table @strong +@item Directive: +@code{.stabs} +@item Type: +@code{N_LSYM} +@item Symbol Descriptor: +@code{t} +@end table -The basic types for the language are described using the N_LSYM stab +The basic types for the language are described using the @code{N_LSYM} stab type. They are boilerplate and are emited by the compiler for each compilation unit. Basic type definitions are not always a complete description of the type and are sometimes circular. The debugger @@ -443,7 +490,10 @@ mostly defined as range types. @node Range types @section Range types defined by min and max value -type descriptor r +@table @strong +@item Type Descriptor: +@code{r} +@end table When defining a range type, if the number after the first semicolon is smaller than the number after the second one, then the two numbers @@ -453,20 +503,27 @@ represent the smallest and the largest values in the range. 4 .text 5 Ltext0: - .stabs "name:sym_descriptor(type)type_def(1)=type_desc(range)type_ref(1);\ - "low_bound;high_bound;",N_LSYM, NIL, NIL, NIL +.stabs "@var{name}: + @var{descriptor} @r{(type)} + @var{type-def}= + @var{type-desc} + @var{type-ref}; + @var{low-bound}; + @var{high-bound}; + ", + N_LSYM, NIL, NIL, NIL 6 .stabs "int:t1=r1;-2147483648;2147483647;",128,0,0,0 7 .stabs "char:t2=r2;0;127;",128,0,0,0 @end example -Here the integer type (1) is defined as a range of the integer type -(1). Likewise char is a range of char. This part of the definition -is circular, but at least the high and low bound values of the range -hold more information about the type. +Here the integer type (@code{1}) is defined as a range of the integer +type (@code{1}). Likewise @code{char} is a range of @code{char}. This +part of the definition is circular, but at least the high and low bound +values of the range hold more information about the type. Here short unsigned int is defined as type number 8 and described as a -range of type int, with a minimum value of 0 and a maximum of 65535. +range of type @code{int}, with a minimum value of 0 and a maximum of 65535. @example 13 .stabs "short unsigned int:t8=r1;0;65535;",128,0,0,0 @@ -475,29 +532,41 @@ range of type int, with a minimum value of 0 and a maximum of 65535. @node Bit-ranges @section Range type defined by number of bits -type descriptor r +@table @strong +@item Type Descriptor: +@code{r} +@end table In a range definition, if the number after the second semicolon is 0, then the number after the first semicolon is the number of bits needed to represent the type. @example - .stabs "name:sym_desc(type)type_def(12)=type_desc(range)type_ref(int)\ - ";number_of_bytes;0;", N_LSYM, NIL, NIL, NIL +.stabs "@var{name}: + @var{desc} + @var{type-def}= + @var{type-desc} + @var{type-ref}; + @var{bit-count}; + 0; + ", + N_LSYM, NIL, NIL, NIL 17 .stabs "float:t12=r1;4;0;",128,0,0,0 18 .stabs "double:t13=r1;8;0;",128,0,0,0 19 .stabs "long double:t14=r1;8;0;",128,0,0,0 @end example -Cosmically enough, the void type is defined directly in terms of +Cosmically enough, the @code{void} type is defined directly in terms of itself. @example - .stabs "name:symbol_desc(type)type_def(15)=type_ref(15)",N_LSYM,NIL,NIL,NIL -@end example +.stabs "@var{name}: + @var{symbol-desc} + @var{type-def}= + @var{type-ref} + ",N_LSYM,NIL,NIL,NIL -@example 20 .stabs "void:t15=15",128,0,0,0 @end example @@ -505,16 +574,21 @@ itself. @node Example @chapter A Comprehensive Example in C -Now we'll examine a second program, example2, which builds on the +Now we'll examine a second program, @code{example2}, which builds on the first example to introduce the rest of the stab types, symbol descriptors, and type descriptors used in C. -@xref{Example2.c} for the complete .c source, -and @pxref{Example2.s} for the .s assembly code. +@xref{Example2.c} for the complete @file{.c} source, +and @pxref{Example2.s} for the @file{.s} assembly code. This description includes parts of those files. @section Flow of control and nested scopes -@code{.stabn}, stab types @code{N_SLINE}, @code{N_LBRAC}, @code{N_RBRAC} (cont.) +@table strong +@item Directive: +@code{.stabn} +@item Types: +@code{N_SLINE}, @code{N_LBRAC}, @code{N_RBRAC} (cont.) +@end table Consider the body of @code{main}, from @file{example2.c}. It shows more about how @code{N_SLINE}, @code{N_RBRAC}, and @code{N_LBRAC} stabs are used. @@ -522,11 +596,11 @@ about how @code{N_SLINE}, @code{N_RBRAC}, and @code{N_LBRAC} stabs are used. @example 20 @{ 21 static float s_flap; -22 int times; -23 for (times=0; times < s_g_repeat; times++)@{ -24 int inner; -25 printf ("Hello world\n"); -26 @} +22 int times; +23 for (times=0; times < s_g_repeat; times++)@{ +24 int inner; +25 printf ("Hello world\n"); +26 @} 27 @}; @end example @@ -535,88 +609,112 @@ non-linear flow of control, and non-contiguous code. In this case, an @code{N_SLINE} stab with the same line number proceeds each block of non-contiguous code generated from the same source line. -The example also shows nested scopes. The @code{N_LBRAC} and @code{N_LBRAC} stabs -that describe block structure are nested in the same order as the -corresponding code blocks, those of the for loop inside those for the -body of main. +The example also shows nested scopes. The @code{N_LBRAC} and +@code{N_LBRAC} stabs that describe block structure are nested in the +same order as the corresponding code blocks, those of the for loop +inside those for the body of main. -@example -@exdent Label for the @code{N_LBRAC} (left brace) stab marking the start of @code{main}. +@noindent +This is the label for the @code{N_LBRAC} (left brace) stab marking the +start of @code{main}. +@example 57 LBB2: +@end example + +@noindent +In the first code range for C source line 23, the @code{for} loop +initialize and test, @code{N_SLINE} (68) records the line number: -@exdent First code range for source line 23,`for' loop initialize and test -@exdent <68> N_SLINE - source line number associated with this code -@exdent .stabn N_SLINE, NIL, line_number, code_address_of_line_start +@example +.stabn N_SLINE, NIL, + @var{line}, + @var{address} 58 .stabn 68,0,23,LM2 59 LM2: -60 st %g0,[%fp-20] +60 st %g0,[%fp-20] 61 L2: -62 sethi %hi(_s_g_repeat),%o0 -63 ld [%fp-20],%o1 -64 ld [%o0+%lo(_s_g_repeat)],%o0 -65 cmp %o1,%o0 -66 bge L3 -67 nop +62 sethi %hi(_s_g_repeat),%o0 +63 ld [%fp-20],%o1 +64 ld [%o0+%lo(_s_g_repeat)],%o0 +65 cmp %o1,%o0 +66 bge L3 +67 nop -@exdent label for the N_LBRAC (start block) marking the start of `for' loop +@exdent label for the @code{N_LBRAC} (start block) marking the start of @code{for} loop 68 LBB3: 69 .stabn 68,0,25,LM3 70 LM3: -71 sethi %hi(LC0),%o1 -72 or %o1,%lo(LC0),%o0 -73 call _printf,0 -74 nop +71 sethi %hi(LC0),%o1 +72 or %o1,%lo(LC0),%o0 +73 call _printf,0 +74 nop 75 .stabn 68,0,26,LM4 76 LM4: -@exdent label for the N_RBRAC (end block) stab marking the end of the for loop +@exdent label for the @code{N_RBRAC} (end block) stab marking the end of the @code{for} loop 77 LBE3: +@end example -@exdent Second code range for source line 23, 'for' loop increment and return - -@exdent <68> N_SLINE - source line number associated with this code +@noindent +Now we come to the second code range for source line 23, the @code{for} +loop increment and return. Once again, @code{N_SLINE} (68) records the +source line number: -@exdent .stabn, SLINE, NIL, line_number, code_address_of_line_continuation. +@example +.stabn, N_SLINE, NIL, + @var{line}, + @var{address} 78 .stabn 68,0,23,LM5 79 LM5: 80 L4: -81 ld [%fp-20],%o0 -82 add %o0,1,%o1 -83 st %o1,[%fp-20] -84 b,a L2 +81 ld [%fp-20],%o0 +82 add %o0,1,%o1 +83 st %o1,[%fp-20] +84 b,a L2 85 L3: 86 .stabn 68,0,27,LM6 87 LM6: -@exdent label for the N_RBRAC (end block) stab marking the end of the for loop +@exdent label for the @code{N_RBRAC} (end block) stab marking the end of the @code{for} loop 88 LBE2: 89 .stabn 68,0,27,LM7 90 LM7: 91 L1: -92 ret -93 restore +92 ret +93 restore 94 .stabs "main:F1",36,0,0,_main 95 .stabs "argc:p1",160,0,0,68 96 .stabs "argv:p20=*21=*2",160,0,0,72 97 .stabs "s_flap:V12",40,0,0,_s_flap.0 98 .stabs "times:1",128,0,0,-20 +@end example + +@noindent +Here is an illustration of stabs describing nested scopes. The scope +nesting is reflected in the nested bracketing stabs (@code{N_LBRAC}, +192, appears here). -@exdent stabs describing nested scopes, the stabs are nested like the scopes are. -@exdent <192> N_LBRAC - left brace, begin lexical block (scope) -@exdent .stabn N_LBRAC,NIL,NIL,code_addr_of_block_start +@example +.stabn N_LBRAC,NIL,NIL, + @var{block-start-address} 99 .stabn 192,0,0,LBB2 ## begin proc label 100 .stabs "inner:1",128,0,0,-24 101 .stabn 192,0,0,LBB3 ## begin for label +@end example -@exdent <224> N_RBRAC - right brace, end lexical block (scope) -@exdent .stabn N_RBRAC,NIL,NIL,code_addr_of_block_end +@noindent +@code{N_RBRAC} (224), ``right brace'' ends a lexical block (scope). + +@example +.stabn N_RBRAC,NIL,NIL, + @var{block-end-address} 102 .stabn 224,0,0,LBE3 ## end for label 103 .stabn 224,0,0,LBE2 ## end proc label @@ -637,43 +735,56 @@ body of main. @node Automatic variables @section Locally scoped automatic variables -@example -.stabs, stab type N_LSYM, - symbol descriptor none -@end example +@table @strong +@item Directive: +@code{.stabs} +@item Type: +@code{N_LSYM} +@item Symbol Descriptor: +none +@end table -In addition to describing types, the N_LSYM stab type also describes -locally scoped automatic variables. Refer again to the body of main -in example2.c. It allocates two automatic variables, 'times' is -scoped to the body of main and 'inner' is scoped to the body of the -for loop. 's_flap' is locally scoped by not automatic and will be -discussed later. +In addition to describing types, the @code{N_LSYM} stab type also +describes locally scoped automatic variables. Refer again to the body +of @code{main} in @file{example2.c}. It allocates two automatic +variables: @samp{times} is scoped to the body of @code{main}, and +@samp{inner} is scoped to the body of the @code{for} loop. +@samp{s_flap} is locally scoped but not automatic, and will be discussed +later. @example 20 @{ 21 static float s_flap; -22 int times; -23 for (times=0; times < s_g_repeat; times++)@{ -24 int inner; -25 printf ("Hello world\n"); -26 @} +22 int times; +23 for (times=0; times < s_g_repeat; times++)@{ +24 int inner; +25 printf ("Hello world\n"); +26 @} 27 @}; @end example -The N_LSYM stab for an automatic variable is located just before the -N_LBRAC stab describing the open brace of the block to which it is +The @code{N_LSYM} stab for an automatic variable is located just before the +@code{N_LBRAC} stab describing the open brace of the block to which it is scoped. @example - <128> N_LSYM - automatic variable, scoped locally to main - .stabs "name:type_ref(int)", N_LSYM, NIL, NIL, frame_pointer_offset +@exdent @code{N_LSYM} (128): automatic variable, scoped locally to @code{main} + +.stabs "@var{name}: + @var{type-ref}", + N_LSYM, NIL, NIL, + @var{frame-pointer-offset} 98 .stabs "times:1",128,0,0,-20 99 .stabn 192,0,0,LBB2 ## begin `main' N_LBRAC - <128> N_LSYM - automatic variable, scoped locally to the for loop - .stabs "name:type_ref(int)", N_LSYM, NIL, NIL, frame_pointer_offset +@exdent @code{N_LSYM} (128): automatic variable, scoped locally to the @code{for} loop + +.stabs "@var{name}: + @var{type-ref}", + N_LSYM, NIL, NIL, + @var{frame-pointer-offset} 100 .stabs "inner:1",128,0,0,-24 101 .stabn 192,0,0,LBB3 ## begin `for' loop N_LBRAC @@ -682,7 +793,7 @@ scoped. Since the character in the string field following the colon is not a letter, there is no symbol descriptor. This means that the stab describes a local variable, and that the number after the colon is a -type reference. In this case it a a reference to the basic type int. +type reference. In this case it a a reference to the basic type @code{int}. Notice also that the frame pointer offset is negative number for automatic variables. @@ -690,66 +801,82 @@ automatic variables. @node Global Variables @section Global Variables -@example -.stabs, stab type N_GSYM, - symbol descriptor G -@end example +@table @strong +@item Directive: +@code{.stabs} +@item Type: +@code{N_GSYM} +@item Symbol Descriptor: +@code{G} +@end table -Global variables are represented by the N_GSYM stab type. The symbol -descriptor, following the colon in the string field, is G. Following -the G is a type reference or type definition. In this example it is a -type reference to the basic C type, char. The first source line in -example2.c +Global variables are represented by the @code{N_GSYM} stab type. The symbol +descriptor, following the colon in the string field, is @samp{G}. Following +the @samp{G} is a type reference or type definition. In this example it is a +type reference to the basic C type, @code{char}. The first source line in +@file{example2.c}, @example 1 char g_foo = 'c'; @end example -yields the following stab. The stab immediatly preceeds the code that +@noindent +yields the following stab. The stab immediately precedes the code that allocates storage for the variable it describes. @example - <32> N_GSYM - global symbol - "name:sym_descriptor(Global)type_ref(char)", N_GSYM, NIL, NIL, NIL -@end example +@exdent @code{N_GSYM} (32): global symbol + +.stabs "@var{name}: + @var{descriptor} + @var{type-ref}", + N_GSYM, NIL, NIL, NIL -@example 21 .stabs "g_foo:G2",32,0,0,0 -22 .global _g_foo -23 .data +22 .global _g_foo +23 .data 24 _g_foo: -25 .byte 99 +25 .byte 99 @end example -The address of the variable represented by the N_GSYM is not contained -in the N_GSYM stab. The debugger gets this information from the +The address of the variable represented by the @code{N_GSYM} is not contained +in the @code{N_GSYM} stab. The debugger gets this information from the external symbol for the global variable. @node Register variables -@section Register variables - -@example -.stabs, stab type N_RSYM, - symbol descriptor r -@end example +@section Global register variables + +@table @strong +@item Directive: +@code{.stabs} +@item Type: +@code{N_RSYM} +@item Symbol Descriptor: +@code{r} +@end table -The following source line defines a global variable, g_bar, which is -allocated in global register %g5. +The following source line defines a global variable, @code{g_bar}, which is +explicitly allocated in global register @code{%g5}. @example 2 register int g_bar asm ("%g5"); @end example -Register variables have their own stab type, N_RSYM, and their own -symbol descriptor, r. The stab's value field contains the number of +Register variables have their own stab type, @code{N_RSYM}, and their own +symbol descriptor, @code{r}. The stab's value field contains the number of the register where the variable data will be stored. Since the variable was not initialized in this compilation unit, the stab is emited at the end of the object file, with the stabs for other -uninitialized globals (bcc). +uninitialized globals (@code{bcc}). @example - <64> N_RSYM - register variable - .stabs "name:sym_desc(reg_var)type_ref(int), N_RSYM, NIL, NIL, reg_num +@exdent @code{N_RSYM} (64): register variable + +.stabs "@var{name}: + @var{descriptor} + @var{type-ref}", + N_RSYM, NIL, NIL, + @var{register} 133 .stabs "g_bar:r1",64,0,0,5 @end example @@ -758,87 +885,108 @@ uninitialized globals (bcc). @node Initialized statics @section Initialized static variables -@example -.stabs, stab type N_STSYM, - symbol descriptors S (file scope), V (procedure scope) -@end example +@table @strong +@item Directive: +@code{.stabs} +@item Type: +@code{N_STSYM} +@item Symbol Descriptors: +@code{S} (file scope), @code{V} (procedure scope) +@end table -Initialized static variables are represented by the N_STSYM stab type. -The symbol descriptor part of the string field shows if the variable -is file scope static (S) or procedure scope static (V). The source -line: +Initialized static variables are represented by the @code{N_STSYM} stab +type. The symbol descriptor part of the string field shows if the +variable is file scope static (@samp{S}) or procedure scope static +(@samp{V}). The source line @example 3 static int s_g_repeat = 2; @end example -yields the following code. The stab is located immediatly preceeding +@noindent +yields the following code. The stab is located immediately preceding the storage for the variable it represents. Since the variable in -this example is file scope static the symbol descriptor is S. +this example is file scope static the symbol descriptor is @samp{S}. @example - <38> N_STSYM - initialized static variable (data seg w/internal linkage) - .stabs "name:sym_desc(static_global)type_ref(int)",N_STSYM,NIL,NIL,var_addr -@end example - -@example +@exdent @code{N_STSYM} (38): initialized static variable (data seg w/internal linkage) + +.stabs "@var{name}: + @var{descriptor} + @var{type-ref}", + N_STSYM,NIL,NIL, + @var{address} + 26 .stabs "s_g_repeat:S1",38,0,0,_s_g_repeat -27 .align 4 +27 .align 4 28 _s_g_repeat: -29 .word 2 +29 .word 2 @end example @node Un-initialized statics @section Un-initialized static variables -@example -.stabs, stab type N_LCSYM, - symbol descriptors S (file scope), V (procedure scope) -@end example +@table @strong +@item Directive: +@code{.stabs} +@item Type: +@code{N_LCSYM} +@item Symbol Descriptors: +@code{S} (file scope), @code{V} (procedure scope) +@end table -Un-initilized static variables are represeted by the N_LCSYM stab -type. The symbol descriptor part of the string shows if the variable -is file scope static (S) or procedure scope static (V). In this -example it is procedure scope static. The source line allocating -s_flap immediatly follows the open brace for the procedure main. +Un-initialized static variables are represented by the @code{N_LCSYM} +stab type. The symbol descriptor part of the string shows if the +variable is file scope static (@samp{S}) or procedure scope static +(@samp{V}). In this example it is procedure scope static. The source +line allocating @code{s_flap} immediately follows the open brace for the +procedure @code{main}. @example 20 @{ 21 static float s_flap; @end example - -The code that reserves storage for the variable s_flap preceeds the -body of body of main. +The code that reserves storage for the variable @code{s_flap} precedes the +body of body of @code{main}. @example -39 .reserve _s_flap.0,4,"bss",4 +39 .reserve _s_flap.0,4,"bss",4 @end example -But since s_flap is scoped locally to main, its stab is located with -the other stabs representing symbols local to main. The stab for -s_flap is located just before the N_LBRAC for main. +But since @code{s_flap} is scoped locally to @code{main}, its stab is +located with the other stabs representing symbols local to @code{main}. +The stab for @code{s_flap} is located just before the @code{N_LBRAC} for +@code{main}. @example - <40> N_LCSYM - un-initialized static var (BSS seg w/internal linkage) - .stabs "name:sym_desc(static_local)type_ref(float)", N_LCSYM, - NIL, NIL, data_addr -@end example +@exdent @code{N_LCSYM} (40): uninitialized static var (BSS seg w/internal linkage) + +.stabs "@var{name}: + @var{descriptor} + @var{type-ref}", + N_LCSYM, NIL, NIL, + @var{address} -@example 97 .stabs "s_flap:V12",40,0,0,_s_flap.0 98 .stabs "times:1",128,0,0,-20 -99 .stabn 192,0,0,LBB2 # N_LBRAC for main. +99 .stabn 192,0,0,LBB2 # N_LBRAC for main. @end example +@c ............................................................ + @node Parameters @section Parameters -@example -.stabs, stab type N_PSYM, - symbol descriptor p -@end example +@table @strong +@item Directive: +@code{.stabs} +@item Type: +@code{N_PSYM} +@item Symbol Descriptor: +@code{p} +@end table Procedure parameters are represented by the N_PSYM stab type. The following source lines show the parameters of the main routine. @@ -852,7 +1000,7 @@ following source lines show the parameters of the main routine. The N_PSYM stabs describing parameters to a function directly follow the N_FUN stab that represents the procedure itself. The N_FUN stab -immediatly follows the code of the procedure it describes. Following +immediately follows the code of the procedure it describes. Following the N_PSYM parameter stabs are any N_LSYM stabs representing local variables. @@ -904,9 +1052,16 @@ type definition. @node Arrays @section Array types -.stabs, stab types N_GSYM, N_LSYM, - - symbol descriptor T, type descriptor ar +@table @strong +@item Directive: +@code{.stabs} +@item Types: +@code{N_GSYM}, @code{N_LSYM} +@item Symbol Descriptor: +@code{T} +@item Type Descriptor: +@code{ar} +@end table As an example of an array type consider the global variable below. @@ -935,21 +1090,27 @@ follows. @exdent N_GSYM, NIL, NIL, NIL 32 .stabs "char_vec:G19=ar1;0;2;2",32,0,0,0 -33 .global _char_vec -34 .align 4 +33 .global _char_vec +34 .align 4 35 _char_vec: -36 .byte 97 -37 .byte 98 -38 .byte 99 +36 .byte 97 +37 .byte 98 +38 .byte 99 @end example @node Enumerations @section Enumerations -@display -.stabs, stab type N_LSYM, - symbol descriptor T, type descriptor e -@end display +@table @strong +@item Directive: +@code{.stabs} +@item Type: +@code{N_LSYM} +@item Symbol Descriptor: +@code{T} +@item Type Descriptor: +@code{e} +@end table The source line below declares an enumeration type. It is defined at file scope between the bodies of main and s_proc in example2.c. @@ -971,7 +1132,7 @@ because type definitions are file scope not global scope. <128> N_LSYM - local symbol .stab "name:sym_dec(type)type_def(22)=sym_desc(enum) enum_name:value(0),enum_name:value(3),enum_name:value(4),;", - N_LSYM, NIL, NIL, NIL + N_LSYM, NIL, NIL, NIL @end display @example @@ -987,10 +1148,16 @@ name:value,. The list of elements ends with a ;. @node Structure tags @section Structure Tags -@display -.stabs, stab type N_LSYM, - symbol descriptor T, type descriptor s -@end display +@table @strong +@item Directive: +@code{.stabs} +@item Type: +@code{N_LSYM} +@item Symbol Descriptor: +@code{T} +@item Type Descriptor: +@code{s} +@end table The following source code declares a structure tag and defines an instance of the structure in global scope. Then a typedef equates the @@ -1027,15 +1194,15 @@ element. @example <128> N_LSYM - type definition .stabs "name:sym_desc(struct tag) Type_def(16)=type_desc(struct type) - struct_bytes + struct_bytes elem_name:type_ref(int),bit_offset,field_bits; - elem_name:type_ref(float),bit_offset,field_bits; - elem_name:type_def(17)=type_desc(dynamic array) index_type(int);NIL; - high_bound(7);element_type(char),bit_offset,field_bits;;", - N_LSYM,NIL,NIL,NIL + elem_name:type_ref(float),bit_offset,field_bits; + elem_name:type_def(17)=type_desc(dynamic array) index_type(int);NIL; + high_bound(7);element_type(char),bit_offset,field_bits;;", + N_LSYM,NIL,NIL,NIL 30 .stabs "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;;",128,0,0,0 + s_char_vec:17=ar1;0;7;2,64,64;s_next:18=*16,128,32;;",128,0,0,0 @end example In this example, two of the structure elements are previously defined @@ -1051,10 +1218,14 @@ definition for an element which is a pointer to type 16. @node Typedefs @section Typedefs -@display -.stabs, stab type N_LSYM, - symbol descriptor t -@end display +@table @strong +@item Directive: +@code{.stabs} +@item Type: +@code{N_LSYM} +@item Symbol Descriptor: +@code{t} +@end table Here is the stab for the typedef equating the structure tag with a type. @@ -1077,7 +1248,7 @@ And here is the code generated for the structure variable. @example 136 .stabs "g_an_s:G16",32,0,0,0 -137 .common _g_an_s,20,"bss" +137 .common _g_an_s,20,"bss" @end example Notice that the structure tag has the same type number as the typedef @@ -1089,10 +1260,16 @@ debugging information. @node Unions @section Unions -@display -.stabs, stab type N_LSYM, - symbol descriptor T, type descriptor u -@end display +@table @strong +@item Directive: +@code{.stabs} +@item Type: +@code{N_LSYM} +@item Symbol Descriptor: +@code{T} +@item Type Descriptor: +@code{u} +@end table Next let's look at unions. In example2 this union type is declared locally to a procedure and an instance of the union is defined. @@ -1108,10 +1285,10 @@ locally to a procedure and an instance of the union is defined. This code generates a stab for the union tag and a stab for the union variable. Both use the N_LSYM stab type. Since the union variable is scoped locally to the procedure in which it is defined, its stab is -located immediatly preceeding the N_LBRAC for the procedure's block +located immediately preceding the N_LBRAC for the procedure's block start. -The stab for the union tag, however is located preceeding the code for +The stab for the union tag, however is located preceding the code for the procedure in which it is defined. The stab type is N_LSYM. This would seem to imply that the union type is file scope, like the struct type s_tag. This is not true. The contents and position of the stab @@ -1175,12 +1352,12 @@ file. @display <32> N_GSYM - global variable .stabs "name:sym_desc(global)type_def(24)=ptr_to(25)= - type_def(func)type_ref(int) + type_def(func)type_ref(int) @end display @example 134 .stabs "g_pf:G24=*25=f1",32,0,0,0 -135 .common _g_pf,4,"bss" +135 .common _g_pf,4,"bss" @end example Since the variable is global, the stab type is N_GSYM and the symbol @@ -1204,11 +1381,11 @@ relocatable addresses. Symbol table entries in a.out have the format: @example 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 */ + 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 */ @}; @end example @@ -1363,18 +1540,18 @@ virtual methods defined. @display .stabs "struct_name:sym_desc(type)type_def(17)=type_desc(struct)struct_bytes(8) - elem_name(delta):type_ref(short int),bit_offset(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);;" - N_LSYM, NIL, NIL + elem_name(delta):type_ref(short int),bit_offset(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);;" + N_LSYM, NIL, NIL @end display - + @smallexample .stabs "$vtbl_ptr_type:t17=s8 - delta:6,0,16;index:6,16,16;pfn:18=*15,32,32;delta2:6,32,16;;" - ,128,0,0,0 + delta:6,0,16;index:6,16,16;pfn:18=*15,32,32;delta2:6,32,16;;" + ,128,0,0,0 @end smallexample @display @@ -1399,8 +1576,8 @@ Consider the following very simple class definition. @example class baseA @{ public: - int Adat; - int Ameth(int in, char other); + int Adat; + int Ameth(int in, char other); @}; @end example @@ -1464,12 +1641,12 @@ information present for virtual methods. @display .stabs "class_name:sym_desc(type)type_def(20)=type_desc(struct)struct_bytes(4) - field_name(Adat):type(int),bit_offset(0),field_bits(32); + field_name(Adat):type(int),bit_offset(0),field_bits(32); - 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 + 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 @end display @smallexample @@ -1491,7 +1668,7 @@ following source: @example main () @{ - baseA AbaseA; + baseA AbaseA; @} @end example @@ -1517,7 +1694,7 @@ defines Ameth: int baseA::Ameth(int in, char other) @{ - return in; + return in; @}; @end example @@ -1533,7 +1710,7 @@ document - Is there already such a doc? >> @example .stabs "name:symbol_desriptor(global function)return_type(int)", - N_FUN, NIL, NIL, code_addr_of_method_start + N_FUN, NIL, NIL, code_addr_of_method_start .stabs "Ameth__5baseAic:F1",36,0,0,_Ameth__5baseAic @end example @@ -1547,7 +1724,7 @@ symbol, by prefixing the symbol name with xs. @example .stabs "name:sym_desc(register param)type_def(19)= - type_desc(ptr to)type_ref(baseA)= + type_desc(ptr to)type_ref(baseA)= type_desc(cross-reference to)baseA:",N_RSYM,NIL,NIL,register_number .stabs "$t:P19=*20=xsbaseA:",64,0,0,8 @@ -1560,7 +1737,7 @@ pointer. @example .stabs "name:sym_desc(value parameter)type_ref(int)", - N_PSYM,NIL,NIL,offset_from_arg_ptr + N_PSYM,NIL,NIL,offset_from_arg_ptr .stabs "in:p1",160,0,0,72 @end example @@ -1584,12 +1761,12 @@ this means that the member is public. The following C++ source: @example class all_data @{ -private: - int priv_dat; +private: + int priv_dat; protected: - char prot_dat; + char prot_dat; public: - float pub_dat; + float pub_dat; @}; @end example @@ -1598,15 +1775,15 @@ generates the following stab to describe the class type all_data. @display .stabs "class_name:sym_desc(type)type_def(19)=type_desc(struct)struct_bytes - data_name:/protection(private)type_ref(int),bit_offset,num_bits; - data_name:/protection(protected)type_ref(char),bit_offset,num_bits; - data_name:(/num omited, private)type_ref(float),bit_offset,num_bits;;" - N_LSYM,NIL,NIL,NIL + data_name:/protection(private)type_ref(int),bit_offset,num_bits; + data_name:/protection(protected)type_ref(char),bit_offset,num_bits; + data_name:(/num omited, private)type_ref(float),bit_offset,num_bits;;" + N_LSYM,NIL,NIL,NIL @end display @smallexample .stabs "all_data:t19=s12 - priv_dat:/01,0,32;prot_dat:/12,32,8;pub_dat:12,64,32;;",128,0,0,0 + priv_dat:/01,0,32;prot_dat:/12,32,8;pub_dat:12,64,32;;",128,0,0,0 @end smallexample Protections for member functions are signified by one digit embeded in @@ -1617,11 +1794,11 @@ definition below: @example class all_methods @{ private: - int priv_meth(int in)@{return in;@}; + int priv_meth(int in)@{return in;@}; protected: - char protMeth(char in)@{return in;@}; + char protMeth(char in)@{return in;@}; public: - float pubMeth(float in)@{return in;@}; + float pubMeth(float in)@{return in;@}; @}; @end example @@ -1631,19 +1808,19 @@ descriptors apply to the class name struct tag and struct type. @display .stabs "class_name:sym_desc(struct tag&type)type_def(21)= - sym_desc(struct)struct_bytes(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)virual(no); - meth_name::type_def(24)=sym_desc(method)returning(float); - :args(float);protection(public)modifier(normal)virtual(no);;", - N_LSYM,NIL,NIL,NIL + sym_desc(struct)struct_bytes(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)virual(no); + meth_name::type_def(24)=sym_desc(method)returning(float); + :args(float);protection(public)modifier(normal)virtual(no);;", + N_LSYM,NIL,NIL,NIL @end display - + @smallexample .stabs "all_methods:Tt21=s1priv_meth::22=##1;:i;0A.;protMeth::23=##2;:c;1A.; - pubMeth::24=##12;:f;2A.;;",128,0,0,0 + pubMeth::24=##12;:f;2A.;;",128,0,0,0 @end smallexample @node Method Modifiers @@ -1661,9 +1838,9 @@ definition below: @example 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; @}; + int ConstMeth (int arg) const @{ return arg; @}; + char VolatileMeth (char arg) volatile @{ return arg; @}; + float ConstVolMeth (float arg) const volatile @{return arg; @}; @}; @end example @@ -1671,18 +1848,18 @@ This class is described by the following stab: @display .stabs "class(A):sym_desc(struct)type_def(20)=type_desc(struct)struct_bytes(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)modifer(const volatile) - virtual(no);;", @dots{} + 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)modifer(const volatile) + virtual(no);;", @dots{} @end display - + @example .stabs "A:T20=s1ConstMeth::21=##1;:i;2B.;VolatileMeth::22=##2;:c;2C.; - ConstVolMeth::23=##12;:f;2D.;;",128,0,0,0 + ConstVolMeth::23=##12;:f;2D.;;",128,0,0,0 @end example @node Virtual Methods @@ -1698,8 +1875,8 @@ description. Consider the class definition below: @example class A @{ public: - int Adat; - virtual int A_virt (int arg) @{ return arg; @}; + int Adat; + virtual int A_virt (int arg) @{ return arg; @}; @}; @end example @@ -1755,14 +1932,14 @@ class. This is preceeded by `~%' and followed by a final semi-colon. @display .stabs "class_name(A):type_def(20)=sym_desc(struct)struct_bytes(8) - field_name(Adat):type_ref(int),bit_offset(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(int);NIL;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) - vtable_index(1);class_first_defining(A);;;~%first_base(A);", - N_LSYM,NIL,NIL,NIL + field_name(Adat):type_ref(int),bit_offset(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(int);NIL;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) + vtable_index(1);class_first_defining(A);;;~%first_base(A);", + N_LSYM,NIL,NIL,NIL @end display @example @@ -1803,29 +1980,29 @@ derived class D. @example class A @{ public: - int Adat; - virtual int A_virt (int arg) @{ return arg; @}; + int Adat; + virtual int A_virt (int arg) @{ return arg; @}; @}; class B @{ public: - int B_dat; - virtual int B_virt (int arg) @{return arg; @}; + int B_dat; + virtual int B_virt (int arg) @{return arg; @}; @}; class C @{ public: - int Cdat; - virtual int C_virt (int arg) @{return arg; @}; + int Cdat; + virtual int C_virt (int arg) @{return arg; @}; @}; 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; @}; + 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; @}; @}; @end example @@ -1851,15 +2028,15 @@ the derivation of this class is encoded as follows. @display .stabs "derived_class_name:symbol_descriptors(struct tag&type)= - type_descriptor(struct)struct_bytes(32)!num_bases(3), - base_virtual(no)inheritence_public(no)base_offset(0), - base_class_type_ref(A); - base_virtual(yes)inheritence_public(no)base_offset(NIL), - base_class_type_ref(B); - base_virtual(no)inheritence_public(yes)base_offset(64), - base_class_type_ref(C); @dots{} + type_descriptor(struct)struct_bytes(32)!num_bases(3), + base_virtual(no)inheritence_public(no)base_offset(0), + base_class_type_ref(A); + base_virtual(yes)inheritence_public(no)base_offset(NIL), + base_class_type_ref(B); + base_virtual(no)inheritence_public(yes)base_offset(64), + base_class_type_ref(C); @dots{} @end display - + @c FIXME! fake linebreaks. @smallexample .stabs "D:Tt31=s32!3,000,20;100,25;0264,28;$vb25:24,128;Ddat: @@ -1951,11 +2128,11 @@ description in the class stab shows this ordering. 19 char* argv[]; 20 @{ 21 static float s_flap; -22 int times; -23 for (times=0; times < s_g_repeat; times++)@{ -24 int inner; -25 printf ("Hello world\n"); -26 @} +22 int times; +23 for (times=0; times < s_g_repeat; times++)@{ +24 int inner; +25 printf ("Hello world\n"); +26 @} 27 @}; 28 29 enum e_places @{first,second=3,last@}; @@ -1982,7 +2159,7 @@ description in the class stab shows this ordering. 1 gcc2_compiled.: 2 .stabs "/cygint/s1/users/jcm/play/",100,0,0,Ltext0 3 .stabs "example2.c",100,0,0,Ltext0 -4 .text +4 .text 5 Ltext0: 6 .stabs "int:t1=r1;-2147483648;2147483647;",128,0,0,0 7 .stabs "char:t2=r2;0;127;",128,0,0,0 @@ -2000,71 +2177,71 @@ description in the class stab shows this ordering. 19 .stabs "long double:t14=r1;8;0;",128,0,0,0 20 .stabs "void:t15=15",128,0,0,0 21 .stabs "g_foo:G2",32,0,0,0 -22 .global _g_foo -23 .data +22 .global _g_foo +23 .data 24 _g_foo: -25 .byte 99 +25 .byte 99 26 .stabs "s_g_repeat:S1",38,0,0,_s_g_repeat -27 .align 4 +27 .align 4 28 _s_g_repeat: -29 .word 2 +29 .word 2 @c FIXME! fake linebreak in line 30 30 .stabs "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;;",128,0,0,0 31 .stabs "s_typedef:t16",128,0,0,0 32 .stabs "char_vec:G19=ar1;0;2;2",32,0,0,0 -33 .global _char_vec -34 .align 4 +33 .global _char_vec +34 .align 4 35 _char_vec: -36 .byte 97 -37 .byte 98 -38 .byte 99 -39 .reserve _s_flap.0,4,"bss",4 -40 .text -41 .align 4 +36 .byte 97 +37 .byte 98 +38 .byte 99 +39 .reserve _s_flap.0,4,"bss",4 +40 .text +41 .align 4 42 LC0: -43 .ascii "Hello world\12\0" -44 .align 4 -45 .global _main -46 .proc 1 +43 .ascii "Hello world\12\0" +44 .align 4 +45 .global _main +46 .proc 1 47 _main: 48 .stabn 68,0,20,LM1 49 LM1: -50 !#PROLOGUE# 0 -51 save %sp,-144,%sp -52 !#PROLOGUE# 1 -53 st %i0,[%fp+68] -54 st %i1,[%fp+72] -55 call ___main,0 -56 nop +50 !#PROLOGUE# 0 +51 save %sp,-144,%sp +52 !#PROLOGUE# 1 +53 st %i0,[%fp+68] +54 st %i1,[%fp+72] +55 call ___main,0 +56 nop 57 LBB2: 58 .stabn 68,0,23,LM2 59 LM2: -60 st %g0,[%fp-20] +60 st %g0,[%fp-20] 61 L2: -62 sethi %hi(_s_g_repeat),%o0 -63 ld [%fp-20],%o1 -64 ld [%o0+%lo(_s_g_repeat)],%o0 -65 cmp %o1,%o0 -66 bge L3 -67 nop +62 sethi %hi(_s_g_repeat),%o0 +63 ld [%fp-20],%o1 +64 ld [%o0+%lo(_s_g_repeat)],%o0 +65 cmp %o1,%o0 +66 bge L3 +67 nop 68 LBB3: 69 .stabn 68,0,25,LM3 70 LM3: -71 sethi %hi(LC0),%o1 -72 or %o1,%lo(LC0),%o0 -73 call _printf,0 -74 nop +71 sethi %hi(LC0),%o1 +72 or %o1,%lo(LC0),%o0 +73 call _printf,0 +74 nop 75 .stabn 68,0,26,LM4 76 LM4: 77 LBE3: 78 .stabn 68,0,23,LM5 79 LM5: 80 L4: -81 ld [%fp-20],%o0 -82 add %o0,1,%o1 -83 st %o1,[%fp-20] -84 b,a L2 +81 ld [%fp-20],%o0 +82 add %o0,1,%o1 +83 st %o1,[%fp-20] +84 b,a L2 85 L3: 86 .stabn 68,0,27,LM6 87 LM6: @@ -2072,8 +2249,8 @@ description in the class stab shows this ordering. 89 .stabn 68,0,27,LM7 90 LM7: 91 L1: -92 ret -93 restore +92 ret +93 restore 94 .stabs "main:F1",36,0,0,_main 95 .stabs "argc:p1",160,0,0,68 96 .stabs "argv:p20=*21=*2",160,0,0,72 @@ -2088,17 +2265,17 @@ description in the class stab shows this ordering. @c FIXME: fake linebreak in line 105 105 .stabs "u_tag:T23=u4u_int:1,0,32;u_float:12,0,32;u_char:21,0,32;;", 128,0,0,0 -106 .align 4 -107 .proc 1 +106 .align 4 +107 .proc 1 108 _s_proc: 109 .stabn 68,0,35,LM8 110 LM8: -111 !#PROLOGUE# 0 -112 save %sp,-120,%sp -113 !#PROLOGUE# 1 -114 mov %i0,%o0 -115 st %i1,[%fp+72] -116 st %i2,[%fp+76] +111 !#PROLOGUE# 0 +112 save %sp,-120,%sp +113 !#PROLOGUE# 1 +114 mov %i0,%o0 +115 st %i1,[%fp+72] +116 st %i2,[%fp+76] 117 LBB4: 118 .stabn 68,0,41,LM9 119 LM9: @@ -2106,8 +2283,8 @@ description in the class stab shows this ordering. 121 .stabn 68,0,41,LM10 122 LM10: 123 L5: -124 ret -125 restore +124 ret +125 restore 126 .stabs "s_proc:f1",36,0,0,_s_proc 127 .stabs "s_arg:p16",160,0,0,0 128 .stabs "s_ptr_arg:p18",160,0,0,72 @@ -2117,9 +2294,9 @@ description in the class stab shows this ordering. 132 .stabn 224,0,0,LBE4 133 .stabs "g_bar:r1",64,0,0,5 134 .stabs "g_pf:G24=*25=f1",32,0,0,0 -135 .common _g_pf,4,"bss" +135 .common _g_pf,4,"bss" 136 .stabs "g_an_s:G16",32,0,0,0 -137 .common _g_an_s,20,"bss" +137 .common _g_an_s,20,"bss" @end example @@ -2147,51 +2324,52 @@ devo/include/aout/stab.def type type #define used to describe dec hex name source program feature ------------------------------------------------ -32 0x20 N_GYSM global symbol -34 0X22 N_FNAME function name (for BSD Fortran) -36 0x24 N_FUN function name or text segment variable for C -38 0x26 N_STSYM static symbol (data segment w/internal linkage) -40 0x28 N_LCSYM .lcomm symbol(BSS-seg variable w/internal linkage) -42 0x2a N_MAIN Name of main routine (not used in C) -48 0x30 N_PC global symbol (for Pascal) -50 0x32 N_NSYMS number of symbols (according to Ultrix V4.0) -52 0x34 N_NOMAP no DST map for sym (according to Ultrix V4.0) -64 0x40 N_RSYM register variable -66 0x42 N_M2C Modula-2 compilation unit -68 0x44 N_SLINE line number in text segment -70 0x46 N_DSLINE line number in data segment - -72 0x48 N_BSLINE line number in bss segment -72 0x48 N_BROWS Sun source code browser, path to .cb file - -74 0x4a N_DEFD GNU Modula2 definition module dependency - -80 0x50 N_EHDECL GNU C++ exception variable -80 0x50 N_MOD2 Modula2 info "for imc" (according to Ultrix V4.0) - -84 0x54 N_CATCH GNU C++ "catch" clause -96 0x60 N_SSYM structure of union element -100 0x64 N_SO path and name of source file -128 0x80 N_LSYM automatic var in the stack (also used for type desc.) -130 0x82 N_BINCL beginning of an include file (Sun only) -132 0x84 N_SOL Name of sub-source (#include) file. -160 0xa0 N_PSYM parameter variable -162 0xa2 N_EINCL end of an include file -164 0xa4 N_ENTRY alternate entry point -192 0xc0 N_LBRAC beginning of a lexical block -194 0xc2 N_EXCL place holder for a deleted include file -196 0xc4 N_SCOPE modula2 scope information (Sun linker) -224 0xe0 N_RBRAC end of a lexical block -226 0xe2 N_BCOMM begin named common block -228 0xe4 N_ECOMM end named common block -232 0xe8 N_ECOML end common (local name) +32 0x20 N_GYSM global symbol +34 0X22 N_FNAME function name (for BSD Fortran) +36 0x24 N_FUN function name or text segment variable for C +38 0x26 N_STSYM static symbol (data segment w/internal linkage) +40 0x28 N_LCSYM .lcomm symbol(BSS-seg variable w/internal linkage) +42 0x2a N_MAIN Name of main routine (not used in C) +48 0x30 N_PC global symbol (for Pascal) +50 0x32 N_NSYMS number of symbols (according to Ultrix V4.0) +52 0x34 N_NOMAP no DST map for sym (according to Ultrix V4.0) +64 0x40 N_RSYM register variable +66 0x42 N_M2C Modula-2 compilation unit +68 0x44 N_SLINE line number in text segment +70 0x46 N_DSLINE line number in data segment + +72 0x48 N_BSLINE line number in bss segment +72 0x48 N_BROWS Sun source code browser, path to .cb file + +74 0x4a N_DEFD GNU Modula2 definition module dependency + +80 0x50 N_EHDECL GNU C++ exception variable +80 0x50 N_MOD2 Modula2 info "for imc" (according to Ultrix V4.0) + +84 0x54 N_CATCH GNU C++ "catch" clause +96 0x60 N_SSYM structure of union element +100 0x64 N_SO path and name of source file +128 0x80 N_LSYM automatic var in the stack + (also used for type desc.) +130 0x82 N_BINCL beginning of an include file (Sun only) +132 0x84 N_SOL Name of sub-source (#include) file. +160 0xa0 N_PSYM parameter variable +162 0xa2 N_EINCL end of an include file +164 0xa4 N_ENTRY alternate entry point +192 0xc0 N_LBRAC beginning of a lexical block +194 0xc2 N_EXCL place holder for a deleted include file +196 0xc4 N_SCOPE modula2 scope information (Sun linker) +224 0xe0 N_RBRAC end of a lexical block +226 0xe2 N_BCOMM begin named common block +228 0xe4 N_ECOMM end named common block +232 0xe8 N_ECOML end common (local name) << used on Gould systems for non-base registers syms >> -240 0xf0 N_NBTEXT ?? -242 0xf2 N_NBDATA ?? -244 0xf4 N_NBBSS ?? -246 0xf6 N_NBSTS ?? -248 0xf8 N_NBLCS ?? +240 0xf0 N_NBTEXT ?? +242 0xf2 N_NBDATA ?? +244 0xf4 N_NBBSS ?? +246 0xf6 N_NBSTS ?? +248 0xf8 N_NBLCS ?? @end smallexample @node Assembler types @@ -2204,57 +2382,57 @@ The #define names for these n_types values are defined in /include/aout/aout64.h @smallexample -dec hex #define -n_type n_type name used to describe +dec hex #define +n_type n_type name used to describe ------------------------------------------ -1 0x0 N_UNDF undefined symbol -2 0x2 N_ABS absolute symbol -- defined at a particular address -3 0x3 extern " (vs. file scope) -4 0x4 N_TEXT text symbol -- defined at offset in text segment -5 0x5 extern " (vs. file scope) -6 0x6 N_DATA data symbol -- defined at offset in data segment -7 0x7 extern " (vs. file scope) -8 0x8 N_BSS BSS symbol -- defined at offset in zero'd segment -9 extern " (vs. file scope) - -12 0x0C N_FN_SEQ func name for Sequent compilers (stab exception) - -49 0x12 N_COMM common sym -- visable after shared lib dynamic link -31 0x1f N_FN file name of a .o file +1 0x0 N_UNDF undefined symbol +2 0x2 N_ABS absolute symbol -- defined at a particular address +3 0x3 extern " (vs. file scope) +4 0x4 N_TEXT text symbol -- defined at offset in text segment +5 0x5 extern " (vs. file scope) +6 0x6 N_DATA data symbol -- defined at offset in data segment +7 0x7 extern " (vs. file scope) +8 0x8 N_BSS BSS symbol -- defined at offset in zero'd segment +9 extern " (vs. file scope) + +12 0x0C N_FN_SEQ func name for Sequent compilers (stab exception) + +49 0x12 N_COMM common sym -- visable after shared lib dynamic link +31 0x1f N_FN file name of a .o file @end smallexample @node Symbol descriptors @section Table C: Symbol descriptors @example -descriptor meaning +descriptor meaning ------------------------------------------------- -(empty) local variable - f local function - F global function - G global variable - p value parameter - r register variable - S static global variable - t type name - T enumeration, struct or type tag - V static local variable +(empty) local variable + f local function + F global function + G global variable + p value parameter + r register variable + S static global variable + t type name + T enumeration, struct or type tag + V static local variable @end example @node Type Descriptors @section Table D: Type Descriptors @example -descriptor meaning +descriptor meaning ------------------------------------- -(empty) type reference - a array type - e enumeration type - f function type - r range type - s structure type - u union specifications - * pointer type +(empty) type reference + a array type + e enumeration type + f function type + r range type + s structure type + u union specifications + * pointer type @end example @@ -2317,7 +2495,7 @@ Finally, any further information. @end menu @node N_GSYM -@section 32 - 0x20 - N_GYSM +@section 32 - 0x20 - N_GYSM @display Global variable. @@ -2327,7 +2505,7 @@ Global variable. @example "name" -> "symbol_name:#type" - # -> G + # -> G @end example Only the "name" field is significant. the location of the variable is @@ -2349,7 +2527,7 @@ Only the "name" field is significant. The location of the symbol is obtained from the corresponding extern symbol. @node N_FUN -@section 36 - 0x24 - N_FUN +@section 36 - 0x24 - N_FUN Function name or text segment variable for C. @display @@ -2359,8 +2537,8 @@ Function name or text segment variable for C. @example @exdent @emph{For functions:} "name" -> "proc_name:#return_type" - # -> F (global function) - f (local function) + # -> F (global function) + f (local function) desc -> line num for proc start. (GCC doesn't set and DBX doesn't miss it.) value -> Code address of proc start. @@ -2378,8 +2556,8 @@ Initialized static symbol (data segment w/internal linkage). @example "name" -> "symbol_name#type" - # -> S (scope global to compilation unit) - -> V (scope local to a procedure) + # -> S (scope global to compilation unit) + -> V (scope local to a procedure) value -> Data Address @end example @@ -2393,13 +2571,13 @@ Unitialized static (.lcomm) symbol(BSS segment w/internal linkage). @example "name" -> "symbol_name#type" - # -> S (scope global to compilation unit) - -> V (scope local to procedure) + # -> S (scope global to compilation unit) + -> V (scope local to procedure) value -> BSS Address @end example @node N_MAIN -@section 42 - 0x2a - N_MAIN +@section 42 - 0x2a - N_MAIN Name of main routine (not used in C) @display @@ -2411,7 +2589,7 @@ Name of main routine (not used in C) @end example @node N_PC -@section 48 - 0x30 - N_PC +@section 48 - 0x30 - N_PC Global symbol (for Pascal) @display @@ -2431,11 +2609,11 @@ global pascal symbol: name,,0,subtype,line @end display @node N_NSYMS -@section 50 - 0x32 - N_NSYMS +@section 50 - 0x32 - N_NSYMS Number of symbols (according to Ultrix V4.0) @display - 0, files,,funcs,lines (stab.def) + 0, files,,funcs,lines (stab.def) @end display @node N_NOMAP @@ -2443,11 +2621,11 @@ Number of symbols (according to Ultrix V4.0) no DST map for sym (according to Ultrix V4.0) @display - name, ,0,type,ignored (stab.def) + name, ,0,type,ignored (stab.def) @end display @node N_RSYM -@section 64 - 0x40 - N_RSYM +@section 64 - 0x40 - N_RSYM register variable @display @@ -2455,7 +2633,7 @@ no DST map for sym (according to Ultrix V4.0) @end display @node N_M2C -@section 66 - 0x42 - N_M2C +@section 66 - 0x42 - N_M2C Modula-2 compilation unit @display @@ -2466,11 +2644,11 @@ Modula-2 compilation unit "name" -> "unit_name,unit_time_stamp[,code_time_stamp] desc -> unit_number value -> 0 (main unit) - 1 (any other unit) + 1 (any other unit) @end example @node N_SLINE -@section 68 - 0x44 - N_SLINE +@section 68 - 0x44 - N_SLINE Line number in text segment @display @@ -2520,7 +2698,7 @@ starts) See comment for N_SLINE above. @node N_BROWS -@section 72 - 0x48 - N_BROWS +@section 72 - 0x48 - N_BROWS Sun source code browser, path to .cb file <> @@ -2529,7 +2707,7 @@ Sun source code browser, path to .cb file Note: type field value overlaps with N_BSLINE @node N_DEFD -@section 74 - 0x4a - N_DEFD +@section 74 - 0x4a - N_DEFD GNU Modula2 definition module dependency GNU Modula-2 definition module dependency. Value is the modification @@ -2562,7 +2740,7 @@ exceptions can be caught here. If Desc is 0, it means all exceptions are caught here. @node N_SSYM -@section 96 - 0x60 - N_SSYM +@section 96 - 0x60 - N_SSYM Structure or union element Value is offset in the structure. @@ -2570,7 +2748,7 @@ Value is offset in the structure. <> @node N_SO -@section 100 - 0x64 - N_SO +@section 100 - 0x64 - N_SO Path and name of source file containing main routine @display @@ -2589,7 +2767,7 @@ contains the path to the source file. The name field of the second N_SO contains the terminal name of the source file itself. @node N_LSYM -@section 128 - 0x80 - N_LSYM +@section 128 - 0x80 - N_LSYM Automatic var in the stack (also used for type descriptors.) @display @@ -2605,9 +2783,9 @@ value -> offset from frame pointer (negative) @exdent @emph{For type descriptors:} "name" -> "name_of_the_type:#type" - # -> t + # -> t -type -> type_ref (or) type_def +type -> type_ref (or) type_def type_ref -> type_number type_def -> type_number=type_desc etc. @@ -2621,7 +2799,7 @@ defines the type. See the Table D for type descriptors and the section on types for what data follows each type descriptor. @node N_BINCL -@section 130 - 0x82 - N_BINCL +@section 130 - 0x82 - N_BINCL Beginning of an include file (Sun only) @@ -2637,7 +2815,7 @@ of the compilation. <> @node N_PSYM -@section 160 - 0xa0 - N_PSYM +@section 160 - 0xa0 - N_PSYM Parameter variable @@ -2647,15 +2825,15 @@ stabs. "name", N_PSYM, NIL, NIL, value @example "name" -> "param_name:#type" - # -> p (value parameter) - -> i (value parameter by reference, indirect access) - -> v (variable parameter by reference) - -> C ( read-only parameter, conformant array bound) - -> x (confomant array value parameter) - -> pP (<>) - -> pF (<>) - -> X (function result variable) - -> b (based variable) + # -> p (value parameter) + -> i (value parameter by reference, indirect access) + -> v (variable parameter by reference) + -> C ( read-only parameter, conformant array bound) + -> x (confomant array value parameter) + -> pP (<>) + -> pF (<>) + -> X (function result variable) + -> b (based variable) value -> offset from the argument pointer (positive). @end example @@ -2709,7 +2887,7 @@ Modula2 scope information (Sun linker) <> @node N_RBRAC -@section 224 - 0xe0 - N_RBRAC +@section 224 - 0xe0 - N_RBRAC End of a lexical block (right brace) @@ -2722,7 +2900,7 @@ value -> code address of the end of the block. @end example @node N_BCOMM -@section 226 - 0xe2 - N_BCOMM +@section 226 - 0xe2 - N_BCOMM Begin named common block. @@ -2730,7 +2908,7 @@ Only the name is significant. <> @node N_ECOMM -@section 228 - 0xe4 - N_ECOMM +@section 228 - 0xe4 - N_ECOMM End named common block. @@ -2752,11 +2930,11 @@ at random, need real info from Gould. >> <> @example -240 0xf0 N_NBTEXT ?? -242 0xf2 N_NBDATA ?? -244 0xf4 N_NBBSS ?? -246 0xf6 N_NBSTS ?? -248 0xf8 N_NBLCS ?? +240 0xf0 N_NBTEXT ?? +242 0xf2 N_NBDATA ?? +244 0xf4 N_NBBSS ?? +246 0xf6 N_NBSTS ?? +248 0xf8 N_NBLCS ?? @end example @node N_LENG @@ -2785,7 +2963,7 @@ structures, unions, and enums (symbol descriptor T) and typedefs (symbol descriptor t) defined at file scope from types defined locally to a procedure or other more local scope. They all use the N_LSYM stab type. Types defined at procedure scope are emited after the -N_RBRAC of the preceeding function and before the code of the +N_RBRAC 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. GDB overcompensates by placing all types in block #1 the block for @@ -2899,41 +3077,41 @@ tables of the executable and object files.) Table E: mapping a.out stab types to xcoff storage classes @example -stab type storage class +stab type storage class ------------------------------- -N_GSYM C_GSYM -N_FNAME unknown -N_FUN C_FUN -N_STSYM C_STSYM -N_LCSYM C_STSYM -N_MAIN unkown -N_PC unknown -N_RSYM C_RSYM -N_RPSYM (0x8e) C_RPSYM -N_M2C unknown -N_SLINE unknown -N_DSLINE unknown -N_BSLINE unknown -N_BROWSE unchanged -N_CATCH unknown -N_SSYM unknown -N_SO unknown -N_LSYM C_LSYM -N_DECL (0x8c) C_DECL -N_BINCL unknown -N_SOL unknown -N_PSYM C_PSYM -N_EINCL unknown -N_ENTRY C_ENTRY -N_LBRAC unknown -N_EXCL unknown -N_SCOPE unknown -N_RBRAC unknown -N_BCOMM C_BCOMM -N_ECOMM C_ECOMM -N_ECOML C_ECOML - -N_LENG unknown +N_GSYM C_GSYM +N_FNAME unknown +N_FUN C_FUN +N_STSYM C_STSYM +N_LCSYM C_STSYM +N_MAIN unkown +N_PC unknown +N_RSYM C_RSYM +N_RPSYM (0x8e) C_RPSYM +N_M2C unknown +N_SLINE unknown +N_DSLINE unknown +N_BSLINE unknown +N_BROWSE unchanged +N_CATCH unknown +N_SSYM unknown +N_SO unknown +N_LSYM C_LSYM +N_DECL (0x8c) C_DECL +N_BINCL unknown +N_SOL unknown +N_PSYM C_PSYM +N_EINCL unknown +N_ENTRY C_ENTRY +N_LBRAC unknown +N_EXCL unknown +N_SCOPE unknown +N_RBRAC unknown +N_BCOMM C_BCOMM +N_ECOMM C_ECOMM +N_ECOML C_ECOML + +N_LENG unknown @end example @node Sun-differences -- 2.30.2