(or individual section) for any given key.
For
\addtoindex{.debug\_types} sections, the
-key is the type signature formed from the algorithm given in
+key is the \addtoindex{type signature}
+formed from the algorithm given in
Section \refersec{datarep:typesignaturecomputation}.
\subsection{Signature Computation Example}
\label{app:signaturecomputationexample}
-As an example, consider a \addtoindex{C++} header file
+As an example,
+\addtoindexx{type signature!example computation}
+consider a \addtoindex{C++} header file
containing the type definitions shown
in Section \refersec{app:typesignatureexamplescsource}.
\end{alltt}
In computing a signature for the type N::C, flatten the type
+\addtoindexx{type signature}
description into a byte stream according to the procedure
outlined in
Section \refersec{datarep:typesignaturecomputation}.
\end{alltt}
In this example, the structure types N::A and N::C have each
-been placed in separate type units. For N::A, the actual
+been placed in separate
+\addtoindexx{type unit}
+type units. For N::A, the actual
definition of the type begins at label L1. The definition
involves references to the int base type and to two pointer
types. The information for each of these referenced types is
-also included in this type unit, since base types and pointer
+also included in this \addtoindex{type unit},
+since base types and pointer
types are trivial types that are not worth the overhead of a
-separate type unit. The last pointer type contains a reference
+separate \addtoindex{type unit}.
+The last pointer type contains a reference
to an incomplete type N::B, which is also included here as
a declaration, since the complete type is unknown and its
signature is therefore unavailable. There is also a reference
to N::C, using
-\livelink{chap:DWFORMrefsig8}{DW\-\_FORM\-\_ref\-\_sig8} to refer to the type signature
+\livelink{chap:DWFORMrefsig8}{DW\-\_FORM\-\_ref\-\_sig8} to
+refer to the type signature
+\addtoindexx{type signature}
for that type.
In computing a signature for the type N::A, flatten the type
\label{app:typesignaturecomputationgrammar}
This section
+\addtoindexx{type signature!computation grammar}
presents a semi-formal grammar that may aid in understanding
how the bytes of the flattened type description are formed
during the type signature computation algorithm of Section
\label{app:separatetypeunits}
Each complete declaration of a globally-visible type can be
+\addtoindexx{type unit}
placed in its own separate type section, with a group key
derived from the type signature. The linker can then remove
all duplicate type declarations based on the key.
For each type defined in a compilation unit, a contribution may
be made to the \addtoindex{.debug\_types}
section of the object file. Each
-such contribution consists of a type unit header
+such contribution consists of a
+\addtoindex{type unit} header
(see Section \refersec{datarep:typeunitheader})
followed by a \livelink{chap:DWTAGtypeunit}{DW\-\_TAG\-\_type\-\_unit} entry, together with
its children.
The header for the series of debugging information entries
contributing to the description of a type that has been
-placed in its own type unit, within the
+placed in its own \addtoindex{type unit}, within the
\addtoindex{.debug\_types} section,
consists of the following information:
\item version (uhalf)
A 2\dash byte unsigned integer representing the version of the
-DWARF information for the compilation unit\addtoindexx{version number!type unit}
+DWARF information for the
+compilation unit\addtoindexx{version number!type unit}
(see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
The value in this field is 4.
\item type\_signature (8\dash byte unsigned integer) \\
-A 64\dash bit unique signature of the type described in this type
+\addtoindexx{type signature}
+A
+\addtoindexx{type\_signature}
+64\dash bit unique signature of the type described in this type
unit.
\textit{An attribute that refers(using \livelink{chap:DWFORMrefsig8}{DW\-\_FORM\-\_ref\-\_sig8}) to
-the primary type contained in this type unit uses this value.}
+the primary type contained in
+this \addtoindex{type unit} uses this value.}
\item type\_offset (section offset) \\
+\addtoindexx{type\_offset}
A 4\dash byte or 8\dash byte unsigned offset
\addtoindexx{section offset!in .debug\_types header}
relative to the beginning
-of the type unit header. This offset refers to the debugging
+of the \addtoindex{type unit} header.
+This offset refers to the debugging
information entry that describes the type. Because the type
may be nested inside a namespace or other structures, and may
contain references to other types that have not been placed in
The third type of reference can identify any debugging
information type entry that has been placed in its own
-type unit. This type of
+\addtoindex{type unit}. This type of
reference (\livetarg{chap:DWFORMrefsig8}{DW\-\_FORM\-\_ref\-\_sig8}) is the
+\addtoindexx{type signature}
64\dash bit type signature
(see Section \refersec{datarep:typesignaturecomputation})
that was computed
\label{datarep:typesignaturecomputation}
A type signature is computed only by the DWARF producer;
+\addtoindexx{type signature computation}
it is used by a DWARF consumer to resolve type references to
-the type definitions that are contained in type units.
+the type definitions that are contained in
+\addtoindexx{type unit}
+type units.
The type signature for a type T0 is formed from the
\addtoindex{MD5 hash}
referent (in Step 4, 5 or 6). If neither treatment applies to
an attribute that references another type entry, the entry
that contains that attribute should not be considered for a
-separate type unit.}
+separate \addtoindex{type unit}.}
\textit{If a debugging information entry contains an attribute from
the list above that would require an unsupported form, that
-entry should not be considered for a separate type unit.}
+entry should not be considered for a separate
+\addtoindex{type unit}.}
-\textit{A type should be considered for a separate type unit only
+\textit{A type should be considered for a separate
+\addtoindex{type unit} only
if all of the type entries that it contains or refers to in
Steps 6 and 7 can themselves each be considered for a separate
-type unit.}
+\addtoindex{type unit}.}
Where the DWARF producer may reasonably choose two or more
different forms for a given attribute, it should choose
type is highly unlikely to produce the same string).}
\textit{A debugging information entry should not be placed in a
-separate type unit if any of the following apply:}
+separate \addtoindex{type unit}
+if any of the following apply:}
\begin{itemize}
\item \textit{The \livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration} attribute is not included because it
indicates that the debugging information entry represents an
incomplete declaration, and incomplete declarations should
-not be placed in separate type units.}
+not be placed in
+\addtoindexx{type unit}
+separate type units.}
\item \textit{The \livelink{chap:DWATdescription}{DW\-\_AT\-\_description} attribute is not included because
it does not provide any information unique to the defining
\label{app:typesafeenumerationexample}
-C++ type\dash safe enumerations can be described in DWARF as illustrated in
+C++ type\dash safe enumerations
+\addtoindexx{type-safe enumeration}
+can be described in DWARF as illustrated in
Section \refersec{app:ctypesafeenumerationexample}.
\begin{lstlisting}
\section{Template Alias Examples}
\label{app:templatealiasexample}
-C++ template aliases can be described in DWARF as illustrated in
+C++ template aliases can be described in DWARF as illustrated
+\addtoindexx{template alias example}
+in
Section \refersec{app:templatealiasexample1}
and
Section \refersec{app:templatealiasexample2}.
\subsection{template alias example 1}
+\addtoindexx{template alias example 1}
\label{app:templatealiasexample1}
\begin{alltt}
! DWARF representation for variable 'b'
\subsection{template alias example 2}
+\addtoindexx{template alias example 2}
\label{app:templatealiasexample2}
\begin{alltt}
! DWARF representation for X<Y<int>>
define a low-level
representation of a source program.
Each debugging information entry consists of an identifying
-tag and a series of
+\addtoindex{tag} and a series of
\addtoindex{attributes}.
An entry, or group of entries together, provide a description of a
corresponding
The tag specifies the class to which an entry belongs
and the attributes define the specific characteristics of the entry.
-The set of tag names is listed in Figure 1.
+The set of
+\addtoindexx{tag names|see{debugging information entry}}
+tag names
+is listed in Figure 1.
The debugging information entries they identify are
described in Sections 3, 4 and 5.
debugging information entry.
Attribute value forms belong
+\addtoindexx{tag names!list of}
to one of the classes shown in Figure \refersec{tab:classesofattributevalue}.
\addtoindex{attributes!list of}
type of reference is the offset of a debugging information
entry in any compilation unit, including one different from
the unit containing the reference. The third type of reference
-is an indirect reference to a type definition using a 64\dash
-bit signature for that type. \\
+is an indirect reference to a
+\addtoindexx{type signature}
+type definition using a 64\dash bit signature
+for that type. \\
\livetargi{chap:string}{string}{string class}
& A null\dash terminated sequence of zero or more
\item \livetarg{chap:DWOPformtlsaddress}{DW\-\_OP\-\_form\-\_tls\-\_address} \\
The \livelink{chap:DWOPformtlsaddress}{DW\-\_OP\-\_form\-\_tls\-\_address} operation pops a value from the
stack, translates it into an address in the current thread's
+\addtoindexx{thread-local storage}
thread\dash local storage \nolink{block}, and pushes the address. If the
DWARF expression containing
the \livelink{chap:DWOPformtlsaddress}{DW\-\_OP\-\_form\-\_tls\-\_address}
operation belongs to the main executable's DWARF info, the
operation uses the main executable's thread\dash local storage
\nolink{block}; if the expression belongs to a shared library's
-DWARF info, then it uses that shared library's thread\dash local
-storage \nolink{block}. Some implementations of
+DWARF info, then it uses that shared library's
+\addtoindexx{thread-local storage}
+thread\dash local storage \nolink{block}.
+Some implementations of
\addtoindex{C} and \addtoindex{C++} support a
\_\_thread storage class. Variables with this storage class
have distinct values and addresses in distinct threads, much
Any
\hypertarget{chap:DWATtypetypeofdeclaration}
debugging information entry describing a declaration that
-has a type has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute, whose value is a
+has a type has
+\addtoindexx{type attribute}
+a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute, whose value is a
reference to another debugging information entry. The entry
referenced may describe a base type, that is, a type that is
not defined in terms of other data types, or it may describe a
Alternatively, the entry referenced may describe a type
modifier, such as constant, packed, pointer, reference or
volatile, which in turn will reference another entry describing
-a type or type modifier (using a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute of its
+a type or type modifier (using
+\addtoindexx{type attribute}
+a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute of its
own). See
Section \refersec{chap:typeentries}
for descriptions of the entries describing
\textit{A compiler may wish to generate debugging information entries
for objects or types that were not actually declared in the
source of the application. An example is a formal parameter
-entry to represent the hidden this parameter that most C++
+%FIXME: The word 'this' should be rendered like a variant italic,
+%FIXME: not as a quoted name.
+entry to represent the
+\addtoindexx{this parameter}
+hidden ``this'' parameter that most C++
implementations pass as the first argument to non-static member
functions.}
three kinds:
\addtoindexx{normal compilation unit}
normal compilation units,
-partial compilation units and type units. A
+partial compilation units and
+\addtoindexx{type unit}
+type units. A
\addtoindex{partial compilation unit}
is related to one or more other compilation units that
import it. A
\label{chap:separatetypeunitentries}
An object file may contain any number of separate type
unit entries, each representing a single complete type
-definition. Each type unit must be uniquely identified by
+definition.
+Each \addtoindex{type unit} must be uniquely identified by
a 64\dash bit signature, stored as part of the type unit, which
can be used to reference the type definition from debugging
information entries in other compilation units and type units.
A type unit is represented by a debugging information entry
with the tag \livetarg{chap:DWTAGtypeunit}{DW\-\_TAG\-\_type\-\_unit}.
-A type unit entry owns debugging
+A \addtoindex{type unit entry} owns debugging
information entries that represent the definition of a single
type, plus additional debugging information entries that may
be necessary to include as part of the definition of the type.
language used to define the type. The set of language names
and their meanings are given in Figure \refersec{fig:languagenames}.
-A type unit entry for a given type T owns a debugging
+A \addtoindex{type unit} entry for a given type T owns a debugging
information entry that represents a defining declaration
of type T. If the type is nested within enclosing types or
namespaces, the debugging information entry for T is nested
the subroutine or entry point
\addtoindexx{return type of subroutine}
is a function that returns a
-value, then its debugging information entry has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type}
-attribute to denote the type returned by that function.
+value, then its debugging information entry has
+\addtoindexx{type attribute}
+a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute
+to denote the type returned by that function.
\textit{Debugging information entries for
\addtoindex{C} void functions should
If a subroutine explicitly declares that it may throw
\addtoindexx{exception thrown|see{thrown type entry}}
-an exception for one or more types, each such type is
+an
+\addtoindexx{thrown exception|see{thrown type entry}}
+exception for one or more types, each such type is
+
represented by a debugging information entry with
\addtoindexx{thrown type entry}
the tag
\livetarg{chap:DWTAGthrowntype}{DW\-\_TAG\-\_thrown\-\_type}.
Each such entry is a child of the entry
representing the subroutine that may throw this type. Each
-thrown type entry contains a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute, whose
+thrown type entry contains
+\addtoindexx{type attribute}
+a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute, whose
value is a reference to an entry describing the type of the
exception that may be thrown.
values of different types. DWARF does not represent the generic
template definition, but does represent each instantiation.}
-A template instantiation is represented by a debugging
+A \addtoindex{template instantiation} is represented by a debugging
information entry with the
\addtoindexx{subprogram entry!use for template instantiation}
-tag \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}. With four
+tag \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}.
+With four
exceptions, such an entry will contain the same attributes and
will have the same types of child entries as would an entry
for a subroutine defined explicitly using the instantiation
\item Each formal parameterized type declaration appearing in the
template definition is represented by a debugging information
entry with the
+\addtoindexx{template type parameter entry}
tag \livetarg{chap:DWTAGtemplatetypeparameter}{DW\-\_TAG\-\_template\-\_type\-\_parameter}.
Each
such entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
null\dash terminated string containing the name of the formal
type parameter as it appears in the source program. The
\addtoindexx{formal type parameter|see{template type parameter entry}}
-template type parameter entry also has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute
+template type parameter entry also has
+\addtoindexx{type attribute}
+a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute
describing the actual type by which the formal is replaced
for this instantiation.
to the combined calling and called execution contexts.}
A trampoline is represented by a debugging information entry
+\addtoindexx{trampoline (subprogam) entry}
with the tag \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram} or \livelink{chap:DWTAGinlinedsubroutine}{DW\-\_TAG\-\_inlined\-\_subroutine}
-that has a \livelink{chap:DWATtrampoline}{DW\-\_AT\-\_trampoline} attribute. The value of that
+that has
+\addtoindexx{trampoline attribute}
+a \livelink{chap:DWATtrampoline}{DW\-\_AT\-\_trampoline} attribute.
+The value of that
attribute indicates the target subroutine of the trampoline,
that is, the subroutine to which the trampoline passes
control. (A trampoline entry may but need not also have a
\textit{In \addtoindex{C++}, trampolines may be used
to implement derived virtual
member functions; such trampolines typically adjust the
+\addtoindexx{this parameter}
implicit this pointer parameter in the course of passing
-control. Other languages and environments may use trampolines
+control.
+Other languages and environments may use trampolines
in a manner sometimes known as transfer functions or transfer
vectors.}
for the with statement
(see Section \refersec{chap:codeaddressesandranges}).
-The with statement entry has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute, denoting
+The with statement entry has
+\addtoindexx{type attribute}
+a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute, denoting
the type of record whose fields may be referenced without full
qualification within the body of the statement. It also has
\addtoindexx{location attribute}
A try \livetargi{chap:tryblock}{block}{try block} is represented
by a debugging information entry
+\addtoindexx{try block entry}
with the tag \livetarg{chap:DWTAGtryblock}{DW\-\_TAG\-\_try\-\_block}.
A catch \livelink{chap:catchblock}{block} is represented by
a debugging information entry with
+\addtoindexx{catch block entry}
the tag \livetarg{chap:DWTAGcatchblock}{DW\-\_TAG\-\_catch\-\_block}.
% nolink as we have links just above and do not have a combo link for both
\addtoindexx{type modifier entry}
A base or user\dash defined type may be modified in different ways
-in different languages. A type modifier is represented in
+\addtoindexx{type modifier|see{constant type entry}}
+\addtoindexx{type modifier|see{reference type entry}}
+\addtoindexx{type modifier|see{restricted type entry}}
+\addtoindexx{type modifier|see{packed type entry}}
+\addtoindexx{type modifier|see{pointer type entry}}
+\addtoindexx{type modifier|see{shared type entry}}
+\addtoindexx{type modifier|see{volatile type entry}}
+in different languages.
+A type modifier is represented in
DWARF by a debugging information entry with one of the tags
given in
Figure \refersec{fig:typemodifiertags}.
string containing the modified type name as it appears in
the source program.
-Each of the type modifier entries has a
+Each of the type modifier entries has
+\addtoindexx{type attribute}
+a
\livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute,
whose value is a reference to a debugging information entry
describing a base type, a user-defined type or another type
\label{chap:typedefentries}
A named type that is defined in terms of another type
definition is represented by a debugging information entry with
+\addtoindexx{typedef entry}
the tag \livetarg{chap:DWTAGtypedef}{DW\-\_TAG\-\_typedef}.
The typedef entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
\addtoindexx{name attribute}
whose value is a null\dash terminated string containing
the name of the typedef as it appears in the source program.
-The typedef entry may also contain a
+The typedef entry may also contain
+\addtoindexx{type attribute}
+a
\livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute whose
value is a reference to the type named by the typedef. If
the debugging information entry for a typedef represents
The ordering attribute may optionally appear on one-dimensional
arrays; it will be ignored.
-An array type entry has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type}
+An array type entry has
+\addtoindexx{type attribute}
+a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute
+describing
\addtoindexx{array!element type}
-attribute describing
the type of each element of the array.
If the amount of storage allocated to hold each element of an
If the complete declaration of a type has been placed in
\hypertarget{chap:DWATsignaturetypesignature}
-a separate type unit
+a separate \addtoindex{type unit}
(see Section \refersec{chap:separatetypeunitentries}),
an incomplete declaration
\addtoindexx{incomplete type}
of that type in the compilation unit may provide
-the unique 64\dash bit signature of the type using a \livelink{chap:DWATsignature}{DW\-\_AT\-\_signature}
+the unique 64\dash bit signature of the type using
+\addtoindexx{type signature}
+a \livelink{chap:DWATsignature}{DW\-\_AT\-\_signature}
attribute.
If a structure, union or class entry represents the definition
the
tag \livetarg{chap:DWTAGinheritance}{DW\-\_TAG\-\_inheritance}.
-An inheritance entry has
+An inheritance entry
+\addtoindexx{type attribute}
+has
\addtoindexx{inheritance entry}
a
\livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute whose value is
the
name attribute is omitted or consists of a single zero byte.
-The data member entry has a
+The data member entry has
+\addtoindexx{type attribute}
+a
\livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute to denote
\addtoindexx{member entry (data)}
the type of that member.
If
\hypertarget{chap:DWATobjectpointerobjectthisselfpointerofmemberfunction}
the member function entry describes a non\dash static member
+\addtoindexx{this pointer attribute|see{object pointer attribute}}
function, then that entry
\addtoindexx{self pointer attribute|see{object pointer attribute}}
has
whose value is
a null\dash terminated string containing the name of the formal
type parameter as it appears in the source program. The
-template type parameter entry also has a
+template type parameter entry also has
+\addtoindexx{type attribute}
+a
\livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute
describing the actual type by which the formal is replaced
for this instantiation.
\item Each formal parameterized value declaration appearing in the
-template definition is represented by a debugging information
-entry with the
+template definition is represented by a
+debugging information entry with the
+\addtoindexx{template value parameter entry}
tag \livetarg{chap:DWTAGtemplatevalueparameter}{DW\-\_TAG\-\_template\-\_value\-\_parameter}.
Each
-such entry may have a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+such entry may have a
+\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
\addtoindexx{name attribute}
whose value is
a null\dash terminated string containing the name of the formal
value parameter as it appears in the source program.
The
\hypertarget{chap:DWATconstvaluetemplatevalueparameter}
-template value parameter entry also has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute
+template value parameter entry
+\addtoindexx{template value parameter entry}
+also has
+\addtoindexx{type attribute}
+a
+\livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute
describing the type of the parameterized value. Finally,
-the template value parameter entry has a \livelink{chap:DWATconstvalue}{DW\-\_AT\-\_const\-\_value}
+the template value parameter entry has a
+\livelink{chap:DWATconstvalue}{DW\-\_AT\-\_const\-\_value}
attribute, whose value is the actual constant value of the
value parameter for this instantiation as represented on the
target architecture.
\item The class type entry and each of its child entries references
-a template type parameter entry in any circumstance where the
+a \addtoindex{template type parameter entry} in any circumstance where the
source template definition references a formal parameterized
-type. Similarly, the class type entry and each of its child
+type.
+Similarly, the class type entry and each of its child
entries references a template value parameter entry in any
circumstance where the source template definition references
a formal parameterized value.
\item If the compiler has generated a special compilation unit to
-hold the template instantiation and that special compilation
+hold the
+\addtoindexx{template instantiation!and special compilaton unit}
+template instantiation and that special compilation
unit has a different name from the compilation unit containing
the template definition, the name attribute for the debugging
information entry representing the special compilation unit
the member entry for the discriminant.
If the variant part does not have a discriminant (tag field),
-the variant part entry has a
+the variant part entry has
+\addtoindexx{type attribute}
+a
\livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute to represent
the tag type.
The condition entry owns \livelink{chap:DWTAGconstant}{DW\-\_TAG\-\_constant} and/or
\livelink{chap:DWTAGsubrangetype}{DW\-\_TAG\-\_subrange\-\_type} entries that describe the constant
-values associated with the condition. If any child entry has
-a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute, that attribute should describe a type
+values associated with the condition. If any child entry
+\addtoindexx{type attribute}
+has
+a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute,
+that attribute should describe a type
compatible with the comparison type (according to the source
language); otherwise the child’s type is the same as the
comparison type.
required to hold an instance of the enumeration.
The \addtoindex{enumeration type entry}
-may have a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute
+may have
+\addtoindexx{type attribute}
+a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute
which refers to the underlying data type used to implement
the enumeration.
If an enumeration type has type safe
+\addtoindexx{type safe enumeration types}
semantics such that
\begin{enumerate}[1.]
the subroutine type name as it appears in the source program.
If the subroutine type describes a function that returns
-a value, then the subroutine type entry has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type}
+a value, then the subroutine type entry has
+\addtoindexx{type attribute}
+a \livelink{chap:DWATtype}{DW\-\_AT\-\_type}
attribute to denote the type returned by the subroutine. If
the types of the arguments are necessary to describe the
subroutine type, then the corresponding subroutine type
specific type) are represented by a debugging information entry
with the tag \livelink{chap:DWTAGformalparameter}{DW\-\_TAG\-\_formal\-\_parameter}.
Each formal parameter
-entry has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute that refers to the type of
+entry has
+\addtoindexx{type attribute}
+a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute that refers to the type of
the formal parameter.
\item The unspecified parameters of a variable parameter list
whose value is a null\dash terminated string containing the
set type name as it appears in the source program.
-The set type entry has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute to denote the
+The set type entry has
+\addtoindexx{type attribute}
+a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute to denote the
type of an element of the set.
If the amount of storage allocated to hold each element of an
string containing the subrange type name as it appears in
the source program.
-The subrange entry may have a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute to describe
+The subrange entry may have
+\addtoindexx{type attribute}
+a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute to describe
the type of object, called the basis type, of whose values
this subrange is a subset.
The
\hypertarget{chap:DWATthreadsscaledupcarrayboundthreadsscalfactor}
-subrange entry may have a \livelink{chap:DWATthreadsscaled}{DW\-\_AT\-\_threads\-\_scaled} attribute,
+subrange entry may have
+\addtoindexx{threads scaled attribute}
+a
+\livelink{chap:DWATthreadsscaled}{DW\-\_AT\-\_threads\-\_scaled} attribute,
which is a \livelink{chap:flag}{flag}.
If present, this attribute indicates whether
this subrange represents a UPC array bound which is scaled
in the source program.
The \addtoindex{pointer to member} entry
-has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute to
+has
+\addtoindexx{type attribute}
+a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute to
describe the type of the class or structure member to which
objects of this type may point.
is a null\dash terminated string containing the type name as it
appears in the source program.
-The file type entry has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute describing
+The file type entry has
+\addtoindexx{type attribute}
+a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute describing
the type of the objects contained in the file.
The file type entry also
\label{chap:templatealiasentries}
A type named using a template alias is represented
-by a debugging information entry with the tag
+by a debugging information entry
+\addtoindexx{template alias entry}
+with the tag
\livetarg{chap:DWTAGtemplatealias}{DW\-\_TAG\-\_template\-\_alias}.
The template alias entry has a
\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
\addtoindexx{name attribute}
whose value is a null\dash terminated string
containing the name of the template alias as it appears in
-the source program. The template alias entry also contains a
-\livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute whose value is a reference to the type
+the source program. The template alias entry also contains
+\addtoindexx{type attribute}
+a
+\livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute
+whose value is a reference to the type
named by the template alias. The template alias entry has
the following child entries:
whose value is a null\dash terminated
string containing the name of the formal type parameter as it
appears in the source program. The template type parameter
-entry also has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute describing the actual
+entry also has
+\addtoindexx{type attribute}
+a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute
+describing the actual
type by which the formal is replaced for this instantiation.
\item Each formal parameterized value declaration
whose value is a null\dash terminated
string containing the name of the formal value parameter
as it appears in the source program. The template value
-parameter entry also has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute describing
+parameter entry also has
+\addtoindexx{type attribute}
+a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute describing
the type of the parameterized value. Finally, the template
value parameter entry has a \livelink{chap:DWATconstvalue}{DW\-\_AT\-\_const\-\_value}
attribute, whose value is the actual constant value of the value parameter for
DWARF Git Projects / dwarf-doc.git / commitdiff