Indexing letter 't' is complete in this change.
authorDavid Anderson <davea42@earthlink.net>
Tue, 4 Dec 2012 16:50:13 +0000 (08:50 -0800)
committerDavid Anderson <davea42@earthlink.net>
Tue, 4 Dec 2012 16:50:13 +0000 (08:50 -0800)
dwarf5/latexdoc/compression.tex
dwarf5/latexdoc/datarepresentation.tex
dwarf5/latexdoc/examples.tex
dwarf5/latexdoc/generaldescription.tex
dwarf5/latexdoc/programscope.tex
dwarf5/latexdoc/typeentries.tex

index 2e2cf5c..f77d5fd 100644 (file)
@@ -768,13 +768,16 @@ will include only one copy of a \addtoindex{section group}
 (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}.
 
@@ -844,6 +847,7 @@ L2:
 \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}.
@@ -990,18 +994,24 @@ L5:
 \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
@@ -1178,6 +1188,7 @@ Section \refersec{app:typesignatureexampleusage}.
 \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
@@ -1358,6 +1369,7 @@ groups.}
 \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.
index 8ecab2a..48abbd6 100644 (file)
@@ -292,7 +292,8 @@ information entry, together with its children.
 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.
@@ -368,7 +369,7 @@ offset portion of an address.
 
 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:
 
@@ -388,7 +389,8 @@ consists of the 4\dash byte value 0xffffffff followed by an
 
 \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.
 
@@ -415,18 +417,24 @@ offset portion of an address.
 
 
 \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
@@ -814,8 +822,9 @@ or when the reference is used.
 
 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
@@ -2347,8 +2356,11 @@ Table 41 \refersec{tab:integerrepresentationnames}.
 \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}
@@ -2530,16 +2542,18 @@ be recursively processed or replaced with the name of the
 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
@@ -2556,7 +2570,8 @@ the type that uniquely identifies that type (i.e., a different
 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}
 
@@ -2581,7 +2596,9 @@ a type.}
 \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
index 68f91b4..0616c3f 100644 (file)
@@ -1872,7 +1872,9 @@ char32_t chr_b = U'h';
 \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}
@@ -2037,7 +2039,9 @@ wrapper<int>.
 \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}.
@@ -2057,6 +2061,7 @@ Beta<long> b;
 
 
 \subsection{template alias example 1}
+\addtoindexx{template alias example 1}
 \label{app:templatealiasexample1}
 \begin{alltt}
 ! DWARF representation for variable 'b'
@@ -2099,6 +2104,7 @@ X<Z<int>> z;
 
 
 \subsection{template alias example 2}
+\addtoindexx{template alias example 2}
 \label{app:templatealiasexample2}
 \begin{alltt}
 ! DWARF representation for X<Y<int>>
index 5b66b62..51b6bc5 100644 (file)
@@ -10,7 +10,7 @@ a series of debugging information entries (DIEs) to
 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 
@@ -18,7 +18,10 @@ 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.
 
@@ -71,6 +74,7 @@ part of the information that guides the interpretation of a
 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}
 
@@ -421,8 +425,10 @@ refer to an entry within that same compilation unit. The second
 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
@@ -755,14 +761,17 @@ Appendix \refersec{app:aggregateexamples}.
 \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
@@ -1496,7 +1505,9 @@ and representation.}
 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
@@ -1504,7 +1515,9 @@ user-defined type, such as an array, structure or enumeration.
 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
@@ -1597,7 +1610,11 @@ Figure \ref{fig:virtualitycodes}.
 \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.}  
 
index 7c39e76..c685913 100644 (file)
@@ -14,7 +14,9 @@ of which there are
 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 
@@ -342,14 +344,15 @@ compilation unit.
 \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.
@@ -362,7 +365,7 @@ constant value is an integer code indicating the source
 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
@@ -915,8 +918,10 @@ If
 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
@@ -1127,14 +1132,19 @@ it may validly throw.}
 
 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.
 
@@ -1146,10 +1156,11 @@ a function that is instantiated differently when called with
 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
@@ -1159,6 +1170,7 @@ types. The exceptions are:
 \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, 
@@ -1167,7 +1179,9 @@ whose value is a
 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.
 
@@ -1631,8 +1645,12 @@ adjust parameters and/or the result (if any) as appropriate
 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
@@ -1667,8 +1685,10 @@ subprogram.)
 \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.}
 
@@ -1800,7 +1820,9 @@ ranges, respectively, of the machine instructions generated
 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}
@@ -1823,9 +1845,11 @@ can handle.}
 
 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
index 1abc452..ba09789 100644 (file)
@@ -425,7 +425,15 @@ definition is deferred to a separate compilation unit).
 \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}.
@@ -438,7 +446,9 @@ whose value is a null\dash terminated
 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
@@ -558,13 +568,16 @@ volatile unsigned char * const restrict p;
 \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
@@ -630,9 +643,11 @@ of the enclosing compilation unit entry) is assumed.
 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
@@ -783,12 +798,14 @@ a \livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration} attribute.
 
 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
@@ -910,7 +927,9 @@ such entry has
 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
@@ -1040,7 +1059,9 @@ program. If the member entry describes an
 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.
@@ -1429,6 +1450,7 @@ description is evaluated.
 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 
@@ -1506,40 +1528,53 @@ such entry may have a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
 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
@@ -1577,7 +1612,9 @@ whose value is a reference to
 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.
 
@@ -1675,8 +1712,11 @@ otherwise it is the type of the parent entry.
 
 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.
@@ -1712,11 +1752,14 @@ attribute whose integer constant value is the number of bytes
 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.]
@@ -1815,7 +1858,9 @@ whose value is a null\dash terminated string containing
 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
@@ -1847,7 +1892,9 @@ interpretations:
 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
@@ -1926,7 +1973,9 @@ a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
 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
@@ -1961,7 +2010,9 @@ whose value is a null\dash terminated
 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.
 
@@ -1979,7 +2030,10 @@ storage needed to hold a value of the subrange type.
 
 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
@@ -2092,7 +2146,9 @@ null\dash terminated string containing the type name as it appears
 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.
 
@@ -2172,7 +2228,9 @@ whose value
 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 
@@ -2288,15 +2346,20 @@ see Appendix \refersec{app:aggregateexamples}.}
 \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:
 
@@ -2311,7 +2374,10 @@ a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
 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
@@ -2324,7 +2390,9 @@ a \livelink{chap:DWATname}{DW\-\_AT\-\_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 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