DBX(5) COMMAND REFERENCE DBX(5) NAME dbx - dbx symbol table information DESCRIPTION The compiler symbol information generated for dbx(1) uses the same structure as described in stab(5), with additional type and scope information appended to a symbol's name. The assembler directive used to describe symbol information has the following format: .stabs ``string'',kind,0,size,value String contains the name, source language type, and scope of the symbol, kind specifies the memory class (e.g., external, static, parameter, local, register), and size specifies the byte size of the object, if relevant. The third field (0 above) is unused. For a global variable or a type, value is unused; for a local variable or parameter, it is the offset from the frame pointer, for a register variable, it is the associated register number. The different kinds of stab entries are interpreted by dbx as follows: N_GSYM The symbol is a global variable (e.g., .comm variable). The variable's address can be found from the corresponding ld(1) symbol entry, thus the value field for N_GSYM symbols is ignored. For example, a global variable x will have both an N_GSYM entry and an ld(1) entry (e.g., N_BSS + N_EXT). See a.out(5) for details about these other entries. N_FUN The symbol is a procedure or function. The size field contains the line number of the entry point. The value field contains the address of the entry point (in the text segment). N_STSYM The symbol is a statically allocated variable for which an initial value has been specified. The value field contains the address of the variable (in the data segment). N_LCSYM The symbol is statically allocated, but not initialized. N_RSYM The symbol is a register variable whose value is kept in the register denoted by the value field. N_PSYM The symbol is a parameter whose value is pushed on the stack before the call. The value field contains the (positive) offset from the frame Printed 5/12/88 1
DBX(5) COMMAND REFERENCE DBX(5) pointer. N_LSYM The symbol is a local variable whose value is stored in the most recently defined procedure's stack frame. The value is the (often negative) offset from the frame pointer. Most source-level information about a symbol is stored in the string field of the stab entry. Since strings are kept in a separate string table in the a.out file, they can be arbitrarily long. Thus there are no restrictions on the kind or length of information in the string field, and it was not necessary to modify the assembler or loader when extending or modifying the format of this information. Below is a grammar describing the syntax of the symbol string. Except in the case of a constant whose value is a string, there are no blanks in a symbol string. NAME: [a-zA-Z_][a-zA-Z_0-9]* INTEGER: [-][0-9][0-9]* REAL: [+-][0-9]*(.[0-9][0-9]*|)([eE]([+-]|)[0-9][0-9]*|) STRING: ``.*'' BSTRING: .* String: NAME `:' Class `:' Class Class: `c' `=' Constant `;' Variable Procedure Parameter NamedType `X' ExportInfo - export or import information (for N_MOD2 only) Constant: `i' INTEGER `r' REAL `c' OrdValue `b' OrdValue `s' STRING `e' TypeId `,' OrdValue `S' TypeId `,' NumElements `,' NumBits `,' BSTRING OrdValue: INTEGER NumElements: INTEGER NumBits: INTEGER Variable: TypeId - local variable of type TypeId Printed 5/12/88 2
DBX(5) COMMAND REFERENCE DBX(5) `r' TypeId - register variable of type TypeId `S' TypeId - module variable of type TypeId (static global in C) `V' TypeId - own variable of type TypeId (static local in C) `G' TypeId - global variable of type TypeId Procedure: Proc - top level procedure Proc `,' NAME `,' NAME - local to first NAME, - second NAME is corresponding ld symbol Proc: `P' - global procedure `Q' - local procedure (static in C) `I' - internal procedure (different calling sequence) `F' TypeId - function returning type TypeId `f' TypeId - local function `J' TypeId - internal function Parameter: `p' TypeId - value parameter of type TypeId `v' TypeId - reference parameter of type TypeId NamedType: `t' TypeId - type name for type TypeId `T' TypeId - C structure tag name for struct TypeId TypeId: INTEGER - Unique (per compilation) number of type INTEGER `=' TypeDef - Definition of type number INTEGER `=' TypeAttrs TypeDef - - Type attributes are extra information associated with a type, - such as alignment constraints or pointer checking semantics. - Dbx interprets some of these, but will ignore rather than complain - about any it does not recognize. Therefore this is a way to add - extra information for prelinking checking. - TypeAttrs: `@@' TypeAttrList `;' TypeAttrList: TypeAttrList `,' TypeAttr TypeAttr TypeAttr: `a' INTEGER - align boundary `s' INTEGER - size in bits `p' INTEGER - pointer class (e.g., checking) BSTRING - something else TypeDef: INTEGER Subrange Array Record `e' EnumList `;' - enumeration `*' TypeId - pointer to TypeId `S' TypeId - set of TypeId `d' TypeId - file of TypeId ProcedureType Printed 5/12/88 3
DBX(5) COMMAND REFERENCE DBX(5) `i' NAME `:' NAME `;' - imported type ModuleName:Name `o' NAME `;' - opaque type `i' NAME `:' NAME `,' TypeId `;' `o' NAME `,' TypeId `;' Subrange: `r' TypeId `;' INTEGER `;' INTEGER Array: `a' TypeId `;' TypeId - array [TypeId] of TypeId `A' TypeId - open array of TypeId `D' INTEGER `,' TypeId - N-dim. dynamic array `E' INTEGER `,' TypeId - N-dim. subarray ProcedureType: `f' TypeId `;' - C function type `f' TypeId `,' NumParams `;' TParamList `;' `p' NumParams `;' TParamList `;' NumParams: INTEGER Record: `s' ByteSize FieldList `;' - structure/record `u' ByteSize FieldList `;' - C union ByteSize: INTEGER FieldList : Field FieldList Field Field: NAME `:' TypeId `,' BitOffset `,' BitSize `;' BitSize: INTEGER BitOffset: INTEGER EnumList: Enum EnumList Enum Enum: NAME `:' OrdValue `,' ParamList: Param ParamList Param Param: NAME `:' TypeId `,' PassBy `;' PassBy: INTEGER TParam: TypeId `,' PassBy `;' TParamList : TParam TParamList TParam Export: INTEGER ExportInfo ExportInfo: `t' TypeId Printed 5/12/88 4
DBX(5) COMMAND REFERENCE DBX(5) `f' TypeId `,' NumParams `;' ParamList `;' `p' NumParams `;' ParamList `;' `v' TypeId `c' `=' Constant A ? indicates that symbol information is continued in the next stab entry; this directive can only occur where a semicolon (;) would otherwise separate the fields of a record or constant in an enumeration. The semicolon is useful when the number of elements in one of these lists is large. SEE ALSO dbx(1), xdb(1), a.out(5), stab(5). Printed 5/12/88 5
%%index%% na:216,86; de:302,2774;3364,1718;5370,2156;7814,1433;9535,471; se:10006,192; %%index%%000000000110