Lines Matching refs:samp

131 With the @samp{-g} option, GCC puts in the @file{.s} file additional
207 example, @samp{:t10=*2} defines type 10 as a pointer to type 2, but does
213 The @var{symbol-descriptor} following the @samp{:} is an alphabetic
217 list of symbol descriptors, see @ref{Symbol Descriptors}.  The @samp{c}
222 @samp{@var{type-number}=}.  A @var{type-number} alone is a type
225 The @samp{@var{type-number}=} form is a type definition, where the
228 may be followed by @samp{=} and nested definitions.  Also, the Lucid
229 compiler will repeat @samp{@var{type-number}=} more than once if it
237 a number follows the @samp{=} then the number is a @var{type-reference}.
251 There is an AIX extension for type attributes.  Following the @samp{=}
252 are any number of type attributes.  Each one starts with @samp{@@} and
253 ends with @samp{;}.  Debuggers, including AIX's dbx and GDB 4.10, skip
257 with a digit, @samp{(}, or @samp{-}; GDB may be unable to distinguish
258 those from the C@t{++} type descriptor @samp{@@}.  The attributes are:
303 backslashes), AIX can use @samp{?} instead of backslash.
318 When compiled with @samp{-g}, the program above yields the following
591 A function is represented by an @samp{F} symbol descriptor for a global
592 (extern) function, and @samp{f} for a static (local) function.  For
609 function; thus @samp{foo:f5} means that foo is a function returning type
620 preceded by @samp{;}.  An argument type of 0 means that additional
621 arguments are being passed, whose types and number may vary (@samp{...}
639 Solaris compiler uses symbol descriptor @samp{P} followed by the return
641 @samp{;}, as in a stab with symbol descriptor @samp{f} or @samp{F}.
642 This use of symbol descriptor @samp{P} can be distinguished from its use
646 The AIX documentation also defines symbol descriptor @samp{J} as an
648 function.  It also says symbol descriptor @samp{m} is a module in
654 necessary), but the AIX documentation defines @samp{I}, @samp{P}, and
655 @samp{Q} for internal, global, and static procedures, respectively.
691 symbol (before the @samp{:}).  This feature is used by GCC, and
757 name of the symbol is @samp{.bb}, then it is the beginning of the block;
758 if the name of the symbol is @samp{.be}; it is the end of the block.
778 The @samp{c} symbol descriptor indicates that this stab represents a
781 is followed by @samp{=} and one of the following:
805 the type explicitly, use @samp{e} instead.
808 Real constant.  @var{value} is the real value, which can be @samp{INF}
809 (optionally preceded by a sign) for infinity, @samp{QNAN} for a quiet
810 NaN (not-a-number), or @samp{SNAN} for a signalling NaN.  If it is a
815 String constant.  @var{string} is a string enclosed in either @samp{'}
816 (in which case @samp{'} characters within the string are represented as
817 @samp{\'} or @samp{"} (in which case @samp{"} characters within the
818 string are represented as @samp{\"}).
840 The above information is followed by @samp{;}.
871 @samp{-}, or @samp{(}, only those characters precluded from being used
874 preceding @samp{@var{type-number}=}.  This is a bad idea; there is no
914 represented by the @samp{G} symbol descriptor.  These stabs use the
954 (@code{C_RSYM} for XCOFF), and their own symbol descriptor, @samp{r}.
959 AIX defines a separate symbol descriptor @samp{d} for floating point
962 the compiler actually uses @samp{d}.
1000 variables within a common block use the @samp{V} symbol descriptor (I
1008 Initialized static variables are represented by the @samp{S} and
1009 @samp{V} symbol descriptors.  @samp{S} means file scope static, and
1010 @samp{V} means procedure scope static.  One exception: in XCOFF, IBM's
1011 xlc compiler always uses @samp{V}, and whether it is file scope or not
1054 @samp{.bs} assembler directive) symbol begins the static block; its
1057 in that static block, and its name is @samp{.bs}.  A @code{C_ESTAT}
1058 (emitted with a @samp{.es} assembler directive) symbol ends the static
1059 block; its name is @samp{.es} and its value and section are ignored.
1065 @samp{S} means that the address is absolute (the linker relocates it)
1066 and symbol descriptor @samp{V} means that the address is relative to the
1072 descriptor @samp{S} symbol be an offset relative to the start of the
1083 stabs such a variable uses the @samp{b} symbol descriptor.
1106 The @samp{b} symbol descriptor is like @samp{V} in that it denotes a
1127 Parameters passed on the stack use the symbol descriptor @samp{p} and
1188 descriptor @samp{P} or @samp{R} to indicate an argument which is in a
1190 is used otherwise.  The symbol's value is the register number.  @samp{P}
1191 and @samp{R} mean the same thing; the difference is that @samp{P} is a
1192 GNU invention and @samp{R} is an IBM (XCOFF) invention.  As of version
1195 There is at least one case where GCC uses a @samp{p} and @samp{r} pair
1196 rather than @samp{P}; this is where the argument is passed in the
1199 According to the AIX documentation, symbol descriptor @samp{D} is for a
1201 unnecessary---why not just use @samp{R} with a register number which
1207 On the sparc and hppa, for a @samp{P} symbol whose type is a structure
1209 sparc, this is also true of a @samp{p} and @samp{r} pair (using Sun
1210 @code{cc}) or a @samp{p} symbol.  However, if a (small) structure is
1211 really in a register, @samp{r} is used.  And, to top it all off, on the
1213 into a register and for which there is a @samp{p} and @samp{r} pair!  I
1214 believe that symbol descriptor @samp{i} is supposed to deal with this
1234 symbol uses symbol descriptor @samp{p} and the type which is passed.
1259 uses a single @samp{p} symbol descriptor for an argument which is stored
1284 so, the parameter symbol (symbol descriptor @samp{p}) (not necessarily
1285 @samp{r} or symbol descriptor omitted symbols) needs to contain the
1293 parameters), then the symbol descriptor is @samp{v} if it is in the
1294 argument list, or @samp{a} if it in a register.  Other than the fact
1296 parameter itself, they are identical to @samp{p} and @samp{R},
1297 respectively.  I believe @samp{a} is an AIX invention; @samp{v} is
1308 @samp{x} for the array itself, and a @samp{C}, which represents the size
1309 of the array.  The value of the @samp{x} stab is the offset in the
1311 it is a guess); the value of the @samp{C} stab is the offset in the
1321 descriptors that may follow the @samp{=} in a type definition.
1349 builtin type descriptors (@samp{b} and @samp{R}), and IBM uses negative
1468 Define an integral type.  @var{signed} is @samp{u} for unsigned or
1469 @samp{s} for signed.  @var{char-flag} is @samp{c} which indicates this
1481 Note that type descriptor @samp{b} used for builtin types conflicts with
1484 will be a digit, @samp{(}, or @samp{-} for a Pascal space type, or
1485 @samp{u} or @samp{s} for a builtin type.
1742 This use of the @samp{b} type descriptor can be distinguished
1745 always a digit, @samp{(}, or @samp{-}.
1764 represented by @samp{M-2;3}, where @samp{-2} is a reference to a
1774 In CHILL, if it is a bitstring instead of a set, also use the @samp{S}
1788 Another way is with the @samp{x} type descriptor, which is followed by
1789 @samp{s} for a structure tag, @samp{u} for a union tag, or @samp{e} for
1790 a enumerator tag, followed by the name of the tag, followed by @samp{:}.
1791 If the name contains @samp{::} between a @samp{<} and @samp{>} pair (for
1792 C@t{++} templates), such a @samp{::} does not end the name---only a single
1793 @samp{:} ends the name; see @ref{Nested Symbols}.
1809 Not all debuggers support the @samp{x} type descriptor, so on some
1814 Modula-2 imported types, at least on AIX, use the @samp{i} type
1816 type is imported, followed by @samp{:}, followed by the name of the
1822 (@pxref{String Field}), or what.  The symbol ends with @samp{;}.
1827 The @samp{r} type descriptor defines a type as a subrange of another
1863 Arrays use the @samp{a} type descriptor.  Following the type descriptor
1881 @samp{@var{type-number}=} if it is defining a new type).  According to a
1883 gives @samp{ar1;1;10;ar1;1;10;4} as a legitimate way to express a two
1888 descriptor @samp{r} and some parameters.  It defines the size of the
1889 array.  In the example below, the range @samp{r1;0;2;} defines an index
1919 @samp{P} type descriptor instead of @samp{a}.  Other than specifying a
1920 packed array, @samp{P} is identical to @samp{a}.
1923 An open array is represented by the @samp{A} type descriptor followed by
1968 Just like @samp{n} except that this is a gstring, not an ordinary
1976 just an array of characters use the @samp{S} type attribute
1982 Enumerations are defined with the @samp{e} type descriptor.
2005 The symbol descriptor (@samp{T}) says that the stab describes a
2006 structure, enumeration, or union tag.  The type descriptor @samp{e},
2007 following the @samp{22=} of the type definition narrows it down to an
2008 enumeration type.  Following the @samp{e} is a list of the elements of
2009 the enumeration.  The format is @samp{@var{name}:@var{value},}.  The
2010 list of elements ends with @samp{;}.  The fact that @var{value} is
2029 of the stabs) if the type is the first thing defined after a @samp{T} or
2030 @samp{t} symbol descriptor (the above example fulfills this
2061 symbol descriptor is @samp{T}, for enumeration, structure, or tag type.
2062 The type descriptor @samp{s} following the @samp{16=} of the type
2065 Following the @samp{s} type descriptor is the number of bytes the
2068 @samp{@var{name}:@var{type}, @var{bit offset from the start of the
2080 types.  For these, the type following the @samp{@var{name}:} part of the
2083 embedded after the @samp{@var{name}:}.  The type definition for the
2103 To give a type a name, use the @samp{t} symbol descriptor.  The type
2116 enumeration, use the @samp{T} symbol descriptor instead.  I believe C is
2121 @samp{o} and is followed by a name.  I don't know what the name
2162 The symbol descriptor @samp{T}, following the @samp{name:} means that
2164 descriptor @samp{u}, following the @samp{23=} of the type definition,
2165 narrows it down to a union type definition.  Following the @samp{u} is
2167 descriptions.  Their format is @samp{@var{name}:@var{type}, @var{bit
2176 @samp{-20} specifies where the variable is stored (@pxref{Stack
2186 The simple, traditional, type is type descriptor @samp{f} is followed by
2192 extensions to specify these, using the @samp{f}, @samp{F}, @samp{p}, and
2193 @samp{R} type descriptors.
2195 First comes the type descriptor.  If it is @samp{f} or @samp{F}, this
2200 followed by a colon (this is only present for type descriptors @samp{R}
2201 and @samp{F} which represent Pascal function or procedure parameters),
2275 do this, use @samp{nm -ap}, which dumps the symbol table, including
2350 is an external symbol.  The upper case @samp{D} signifies that the
2425 * Method Type Descriptor::      The @samp{#} type descriptor
2426 * Member Type Descriptor::      The @samp{@@} type descriptor
2440 there should be stabs with both @samp{t} and @samp{T} symbol descriptors
2444 @samp{T} symbol descriptor is followed by @samp{t}, then the stab
2473 which contains @samp{::}.  Such a pair of colons does not end the name
2477 @samp{:} cannot be used as a symbol descriptor.
2479 For example, if the string for a stab is @samp{foo::bar::baz:t5=*6},
2480 then @code{foo::bar::baz} is the name of the symbol, @samp{t} is the
2481 symbol descriptor, and @samp{5=*6} is the type information.
2568 still begins with @samp{name:} but then goes on to define a new type number
2579 Normally this will be a type declared using the @samp{#} type
2581 are declared using the @samp{f} type descriptor instead; see
2585 other methods.  It is @samp{op$::@var{operator-name}.} where
2586 @var{operator-name} is the operator name such as @samp{+} or @samp{+=}.
2594 map to @samp{ic}.
2600 this case, @samp{A} means that it is a normal function definition.  The dot
2695 @samp{xs}.
2720 @section The @samp{#} Type Descriptor
2725 If the @samp{#} is immediately followed by another @samp{#}, the second
2730 Otherwise, the single @samp{#} is followed by the class type, a comma,
2743 @section The @samp{@@} Type Descriptor
2745 The @samp{@@} type descriptor is used together with the @samp{*} type
2763 (@pxref{String Field}); both use type descriptor @samp{@@}.
2764 Fortunately, the @samp{@@} type descriptor used in this C@t{++} sense always
2765 will be followed by a digit, @samp{(}, or @samp{-}, and type attributes
2776 If the character following the @samp{@var{field-name}:} part of the
2777 string is @samp{/}, then the next character is the visibility.  @samp{0}
2778 means private, @samp{1} means protected, and @samp{2} means public.
2782 specified the field is public.  The visibility @samp{9} means that the
2785 Visibility @samp{9} is not supported by GDB 4.11; this should be fixed
2809 @samp{vis:T19=s12} indicates that type number 19 is a 12 byte structure
2811 (@samp{/0}), type int (@samp{1}), and offset and size @samp{,0,32;}.
2812 The @code{prot} field has protected visibility (@samp{/1}), type char
2813 (@samp{2}) and offset and size @samp{,32,8;}.  The @code{pub} field has
2814 type float (@samp{12}), and offset and size @samp{,64,32;}.
2833 of an @samp{A} in each case.  Notice also that in this case two symbol
2861 character values.  Normal methods use @samp{A}, const methods use
2862 @samp{B}, volatile methods use @samp{C}, and const volatile methods use
2863 @samp{D}.  Consider the class definition below:
2912 struct is @samp{Adat}, an integer, starting at structure offset 0 and
2918 name of the vtable pointer field starts with @samp{$vf} and continues with a
2921 @samp{$vf20}, followed by the usual colon.
2937 @samp{A} there is an asterisk, indicating that the function is virtual.
2958 class.  This is preceded by @samp{~%} and followed by a final semi-colon.
2997 The virtual character is @samp{1} if the base class is virtual and
2998 @samp{0} if not.  The visibility character is @samp{2} if the derivation
2999 is public, @samp{1} if it is protected, and @samp{0} if it is private.
3108 name is @samp{$vb} followed by a type reference to the virtual base class.
3110 is @samp{$vb25}.
3886 putting a line number in desc is controlled by @samp{#ifdef
3888 information if you say @samp{list @var{var}}.  In reality, @var{var} can
3889 be a variable defined in the program and GDB says @samp{function
3894 structures, unions, and enums (symbol descriptor @samp{T}) and typedefs
3895 (symbol descriptor @samp{t}) defined at file scope from types defined locally
3902 symbols of file scope.  This is true for default, @samp{-ansi} and
3903 @samp{-traditional} compiler options. (Bugs gcc/1063, gdb/1066.)
4029 the Sun compiler this affects @samp{S} symbol descriptor stabs