Indexing letter 's'.
[dwarf-doc.git] / dwarf5 / latexdoc / generaldescription.tex
index a1fd70f..5b66b62 100644 (file)
@@ -2,13 +2,19 @@
 \label{chap:generaldescription}
 \section{The Debugging Entry (DIE)}
 \label{chap:thedebuggingentrydie}
-DWARF uses a series of debugging information entries (DIEs) to 
-define a low\dash{} level
+DWARF 
+\addtoindexx{debugging information entry}
+uses 
+\addtoindexx{DIE|see{debugging information entry}}
+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 attributes. 
+tag and a series of 
+\addtoindex{attributes}. 
 An entry, or group of entries together, provide a description of a
-corresponding entity in the source program. 
+corresponding 
+\addtoindex{entity} in the source program. 
 The tag specifies the class to which an entry belongs
 and the attributes define the specific characteristics of the entry.
 
@@ -26,25 +32,29 @@ debugging information entries, are described in
 this section and not necessarily mentioned in all
 contexts where they may be appropriate. 
 Examples include \livelink{chap:DWATartificial}{DW\-\_AT\-\_artificial}, the declaration
-coordinates, and \livelink{chap:DWATdescription}{DW\-\_AT\-\_description}, among others.
+coordinates, and 
+\livelink{chap:DWATdescription}{DW\-\_AT\-\_description}, among others.
 
 The debugging information entries are contained 
-in the .debug\_info and .debug\_types
+in the \addtoindex{.debug\_info} and 
+\addtoindex{.debug\_types}
 sections of an object file.
 
 
-
 \section{Attribute Types}
 \label{chap:attributetypes}
 Each attribute value is characterized by an attribute name. 
+\addtoindexx{attribute duplication}
 No more than one attribute with a given name may appear in any
 debugging information entry. 
 There are no limitations on the
+\addtoindexx{attribute ordering}
 ordering of attributes within a debugging information entry.
 
 The attributes are listed in Figure 2.  
 
 The permissible values
+\addtoindexx{attribute value classes}
 for an attribute belong to one or more classes of attribute
 value forms.  
 Each form class may be represented in one or more ways. 
@@ -62,6 +72,7 @@ debugging information entry.
 
 Attribute value forms belong
 to one of the classes shown in Figure \refersec{tab:classesofattributevalue}.
+\addtoindex{attributes!list of}
 
 % These each need to link to definition page: FIXME
 \begin{figure}[here]
@@ -143,220 +154,221 @@ to one of the classes shown in Figure \refersec{tab:classesofattributevalue}.
   \hline
 \endlastfoot
 \livetarg{chap:DWATabstractorigin}{DW\-\_AT\-\_abstract\-\_origin}
-&\livelink{chap:DWATabstractorigininlineinstance}{Inline instances of inline subprograms} \\
+&\livelinki{chap:DWATabstractorigininlineinstance}{Inline instances of inline subprograms} {inline instances of inline subprograms} \\
 % Heren livelink we cannot use \dash or \dash{}.
-&\livelink{chap:DWATabstractoriginoutoflineinstance}{Out-of-line instances of inline subprograms} \\
+&\livelinki{chap:DWATabstractoriginoutoflineinstance}{Out-of-line instances of inline subprograms}{out-of-line instances of inline subprograms} \\
 \livetarg{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility}
-&\livelink{chap:DWATaccessibilitycandadadeclarations}{C++ and Ada declarations} \\
+&\livelink{chap:DWATaccessibilitycandadadeclarations}{C++ and Ada declarations} \addtoindexx{Ada} \\
 &\livelink{chap:DWATaccessibilitycppbaseclasses}{C++ base classes} \\
 &\livelink{chap:DWATaccessibilitycppinheritedmembers}{C++ inherited members} \\
 \livetarg{chap:DWATaddressclass}{DW\-\_AT\-\_address\-\_class}
-&\livelink{chap:DWATadressclasspointerorreferencetypes}{Pointer or reference types} \\
-&\livelink{chap:DWATaddressclasssubroutineorsubroutinetype}{Subroutine or subroutine type} \\
+&\livelinki{chap:DWATadressclasspointerorreferencetypes}{Pointer or reference types}{pointer or reference types}  \\
+&\livelinki{chap:DWATaddressclasssubroutineorsubroutinetype}{Subroutine or subroutine type}{subroutine or subroutine type} \\
 \livetarg{chap:DWATallocated}{DW\-\_AT\-\_allocated}
-&\livelink{chap:DWATallocatedallocationstatusoftypes}{Allocation status of types} \\
+&\livelinki{chap:DWATallocatedallocationstatusoftypes}{Allocation status of types}{allocation status of types}  \\
 \livetarg{chap:DWATartificial}{DW\-\_AT\-\_artificial}
-&\livelink{chap:DWATartificialobjectsortypesthat}{Objects or types that are not
-actually declared in the source} \\
+&\livelinki{chap:DWATartificialobjectsortypesthat}{Objects or types that are not
+actually declared in the source}{objects or types that are not actually declared in the source}  \\
 \livetarg{chap:DWATassociated}{DW\-\_AT\-\_associated} 
-&\livelink{chap:DWATassociatedassociationstatusoftypes}{Association status of types} \\
+&\livelinki{chap:DWATassociatedassociationstatusoftypes}{Association status of types}{association status of types} \\
 \livetarg{chap:DWATbasetypes}{DW\-\_AT\-\_base\-\_types} 
-&\livelink{chap:DWATbasetypesprimitivedatatypesofcompilationunit}{Primitive data types of compilation unit} \\
+&\livelinki{chap:DWATbasetypesprimitivedatatypesofcompilationunit}{Primitive data types of compilation unit}{primitive data types of compilation unit} \\
 \livetarg{chap:DWATbinaryscale}{DW\-\_AT\-\_binary\-\_scale} 
-&\livelink{chap:DWATbinaryscalebinaryscalefactorforfixedpointtype}{Binary scale factor for fixed-point type} \\
+&\livelinki{chap:DWATbinaryscalebinaryscalefactorforfixedpointtype}{Binary scale factor for fixed-point type}{binary scale factor for fixed-point type} \\
 \livetarg{chap:DWATbitoffset}{DW\-\_AT\-\_bit\-\_offset} 
-&\livelink{chap:DWATbitoffsetbasetypebitlocation}{Base type bit location} \\
-&\livelink{chap:DWATbitoffsetdatamemberbitlocation}{Data member bit location} \\
+&\livelinki{chap:DWATbitoffsetbasetypebitlocation}{Base type bit location}{base type bit location} \\
+&\livelinki{chap:DWATbitoffsetdatamemberbitlocation}{Data member bit location}{data member bit location} \\
 \livetarg{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size} 
-&\livelink{chap:DWATbitsizebasetypebitsize}{Base type bit size} \\
-&\livelink{chap:DWATbitsizedatamemberbitsize}{Data member bit size} \\
+&\livelinki{chap:DWATbitsizebasetypebitsize}{Base type bit size}{base type bit size} \\
+&\livelink{chap:DWATbitsizedatamemberbitsize}{Data member bit size}{data member bit size} \\
 \livetarg{chap:DWATbitstride}{DW\-\_AT\-\_bit\-\_stride} 
-&\livelink{chap:DWATbitstridearrayelementstrideofarraytype}{Array element stride (of array type)} \\
-&\livelink{chap:DWATbitstridesubrangestridedimensionofarraytype}{Subrange stride (dimension of array type)} \\
-&\livelink{chap:DWATbitstrideenumerationstridedimensionofarraytype}{Enumeration stride (dimension of array type)} \\
+&\livelinki{chap:DWATbitstridearrayelementstrideofarraytype}{Array element stride (of array type)}{array element stride (of array type)} \\
+&\livelinki{chap:DWATbitstridesubrangestridedimensionofarraytype}{Subrange stride (dimension of array type)}{subrange stride (dimension of array type)} \\
+&\livelinki{chap:DWATbitstrideenumerationstridedimensionofarraytype}{Enumeration stride (dimension of array type)}{enumeration stride (dimension of array type)} \\
 \livetarg{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} 
-&\livelink{chap:DWATbytesizedataobjectordatatypesize}{Data object or data type size} \\
+&\livelinki{chap:DWATbytesizedataobjectordatatypesize}{Data object or data type size}{data object or data type size} \\
 \livetarg{chap:DWATbytestride}{DW\-\_AT\-\_byte\-\_stride} 
-&\livelink{chap:DWATbytestridearrayelementstrideofarraytype}{Array element stride (of array type)} \\
-&\livelink{chap:DWATbytestridesubrangestridedimensionofarraytype}{Subrange stride (dimension of array type)} \\
-&\livelink{chap:DWATbytestrideenumerationstridedimensionofarraytype}{Enumeration stride (dimension of array type)} \\
+&\livelinki{chap:DWATbytestridearrayelementstrideofarraytype}{Array element stride (of array type)}{array element stride (of array type)} \\
+&\livelinki{chap:DWATbytestridesubrangestridedimensionofarraytype}{Subrange stride (dimension of array type)}{subrange stride (dimension of array type)} \\
+&\livelinki{chap:DWATbytestrideenumerationstridedimensionofarraytype}{Enumeration stride (dimension of array type)}{enumeration stride (dimension of array type)} \\
 \livetarg{chap:DWATcallcolumn}{DW\-\_AT\-\_call\-\_column} 
-&\livelink{chap:DWATcallcolumncolumnpositionofinlinedsubroutinecall}{Column position of inlined subroutine call}\\
+&\livelinki{chap:DWATcallcolumncolumnpositionofinlinedsubroutinecall}{Column position of inlined subroutine call}{column position of inlined subroutine call}\\
 \livetarg{chap:DWATcallfile}{DW\-\_AT\-\_call\-\_file}
-&\livelink{chap:DWATcallfilefilecontaininginlinedsubroutinecall}{File containing inlined subroutine call} \\
+&\livelinki{chap:DWATcallfilefilecontaininginlinedsubroutinecall}{File containing inlined subroutine call}{file containing inlined subroutine call} \\
 \livetarg{chap:DWATcallline}{DW\-\_AT\-\_call\-\_line} 
-&\livelink{chap:DWATcalllinelinenumberofinlinedsubroutinecall}{Line number of inlined subroutine call} \\
+&\livelinki{chap:DWATcalllinelinenumberofinlinedsubroutinecall}{Line number of inlined subroutine call}{line number of inlined subroutine call} \\
 \livetarg{chap:DWATcallingconvention}{DW\-\_AT\-\_calling\-\_convention} 
-&\livelink{chap:DWATcallingconventionsubprogramcallingconvention}{Subprogram calling convention} \\
+&\livelinki{chap:DWATcallingconventionsubprogramcallingconvention}{Subprogram calling convention}{subprogram calling convention} \\
 \livetarg{chap:DWATcommonreference}{DW\-\_AT\-\_common\-\_reference}
-&\livelink{chap:commonreferencecommonblockusage}{Common block usage} \\
+&\livelinki{chap:commonreferencecommonblockusage}{Common block usage}{common block usage} \\
 \livetarg{chap:DWATcompdir}{DW\-\_AT\-\_comp\-\_dir}
-&\livelink{chap:DWATcompdircompilationdirectory}{Compilation directory} \\
+&\livelinki{chap:DWATcompdircompilationdirectory}{Compilation directory}{compilation directory} \\
 \livetarg{chap:DWATconstvalue}{DW\-\_AT\-\_const\-\_value}
-&\livelink{chap:DWATconstvalueconstantobject}{Constant object} \\
-&\livelink{chap:DWATconstvalueenumerationliteralvalue}{Enumeration literal value} \\
-&\livelink{chap:DWATconstvaluetemplatevalueparameter}{Template value parameter} \\
+&\livelinki{chap:DWATconstvalueconstantobject}{Constant object}{constant object} \\
+&\livelinki{chap:DWATconstvalueenumerationliteralvalue}{Enumeration literal value}{enumeration literal value} \\
+&\livelinki{chap:DWATconstvaluetemplatevalueparameter}{Template value parameter}{template value parameter} \\
 \livetarg{chap:DWATconstexpr}{DW\-\_AT\-\_const\-\_expr}
-&\livelink{chap:DWATconstexprcompiletimeconstantobject}{Compile-time constant object} \\
-&\livelink{chap:DWATconstexprcompiletimeconstantfunction}{Compile-time constant function} \\
+&\livelinki{chap:DWATconstexprcompiletimeconstantobject}{Compile-time constant object}{compile-time constant object} \\
+&\livelinki{chap:DWATconstexprcompiletimeconstantfunction}{Compile-time constant function}{compile-time constant function} \\
 \livetarg{chap:DWATcontainingtype}{DW\-\_AT\-\_containing\-\_type}
-&\livelink{chap:DWATcontainingtypecontainingtypeofpointertomembertype}{Containing type of pointer to member type} \\
+&\livelinki{chap:DWATcontainingtypecontainingtypeofpointertomembertype}{Containing type of pointer to member type}{containing type of pointer to member type} \\
 \livetarg{chap:DWATcount}{DW\-\_AT\-\_count}
-&\livelink{chap:DWATcountelementsofsubrangetype}{Elements of subrange type} \\
+&\livelinki{chap:DWATcountelementsofsubrangetype}{Elements of subrange type}{elements of subrange type} \\
 \livetarg{chap:DWATdatabitoffset}{DW\-\_AT\-\_data\-\_bit\-\_offset}
-&\livelink{chap:DWATdatabitoffsetbasetypebitlocation}{Base type bit location} \\
-&\livelink{chap:DWATdatabitoffsetdatamemberbitlocation}{Data member bit location} \\
+&\livelinki{chap:DWATdatabitoffsetbasetypebitlocation}{Base type bit location}{base type bit location} \\
+&\livelinki{chap:DWATdatabitoffsetdatamemberbitlocation}{Data member bit location}{data member bit location} \\
 \livetarg{chap:DWATdatalocation}{DW\-\_AT\-\_data\-\_location} 
-&\livelink{chap:DWATdatalocationindirectiontoactualdata}{Indirection to actual data} \\
+&\livelinki{chap:DWATdatalocationindirectiontoactualdata}{Indirection to actual data}{indirection to actual data} \\
 \livetarg{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location}
-&\livelink{chap:DWATdatamemberlocationdatamemberlocation}{Data member location} \\
-&\livelink{chap:DWATdatamemberlocationinheritedmemberlocation}{Inherited member location} \\
+&\livelinki{chap:DWATdatamemberlocationdatamemberlocation}{Data member location}{data member location} \\
+&\livelinki{chap:DWATdatamemberlocationinheritedmemberlocation}{Inherited member location}{inherited member location} \\
 \livetarg{chap:DWATdecimalscale}{DW\-\_AT\-\_decimal\-\_scale}
-&\livelink{chap:DWATdecimalscaledecimalscalefactor}{Decimal scale factor} \\
+&\livelinki{chap:DWATdecimalscaledecimalscalefactor}{Decimal scale factor}{decimal scale factor} \\
 \livetarg{chap:DWATdecimalsign}{DW\-\_AT\-\_decimal\-\_sign}
-&\livelink{chap:DWATdecimalsigndecimalsignrepresentation}{Decimal sign representation} \\
+&\livelinki{chap:DWATdecimalsigndecimalsignrepresentation}{Decimal sign representation}{decimal sign representation} \\
 \livetarg{chap:DWATdeclcolumn}{DW\-\_AT\-\_decl\-\_column}
-&\livelink{chap:DWATdeclcolumncolumnpositionofsourcedeclaration}{Column position of source declaration} \\
+&\livelinki{chap:DWATdeclcolumncolumnpositionofsourcedeclaration}{Column position of source declaration}{column position of source declaration} \\
 \livetarg{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file}
-&\livelink{chap:DWATdeclfilefilecontainingsourcedeclaration}{File containing source declaration} \\
+&\livelinki{chap:DWATdeclfilefilecontainingsourcedeclaration}{File containing source declaration}{file containing source declaration} \\
 \livetarg{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line}
-&\livelink{chap:DWATdecllinelinenumberofsourcedeclaration}{Line number of source declaration} \\
+&\livelinki{chap:DWATdecllinelinenumberofsourcedeclaration}{Line number of source declaration}{line number of source declaration} \\
 \livetarg{chap:DWATdeclaration}{DW\-\_AT\-\_declaration}
-&\livelink{chap:DWATdeclarationincompletenondefiningorseparateentitydeclaration}{Incomplete, non-defining, or separate entity declaration} \\
+&\livelinki{chap:DWATdeclarationincompletenondefiningorseparateentitydeclaration}{Incomplete, non-defining, or separate entity declaration}{incomplete, non-defining, or separate entity declaration} \\
 \livetarg{chap:DWATdefaultvalue}{DW\-\_AT\-\_default\-\_value}
-&\livelink{chap:DWATdefaultvaluedefaultvalueofparameter}{Default value of parameter} \\
+&\livelinki{chap:DWATdefaultvaluedefaultvalueofparameter}{Default value of parameter}{default value of parameter} \\
 \livetarg{chap:DWATdescription}{DW\-\_AT\-\_description} 
-&\livelink{chap:DWATdescriptionartificialnameordescription}{Artificial name or description} \\
+&\livelinki{chap:DWATdescriptionartificialnameordescription}{Artificial name or description}{artificial name or description} \\
 \livetarg{chap:DWATdigitcount}{DW\-\_AT\-\_digit\-\_count}
-&\livelink{chap:DWATdigitcountdigitcountforpackeddecimalornumericstringtype}{Digit count for packed decimal or numeric string type} \\
+&\livelinki{chap:DWATdigitcountdigitcountforpackeddecimalornumericstringtype}{Digit count for packed decimal or numeric string type}{digit count for packed decimal or numeric string type} \\
 \livetarg{chap:DWATdiscr}{DW\-\_AT\-\_discr}
-&\livelink{chap:DWATdiscrdiscriminantofvariantpart}{Discriminant of variant part} \\
+&\livelinki{chap:DWATdiscrdiscriminantofvariantpart}{Discriminant of variant part}{discriminant of variant part} \\
 \livetarg{chap:DWATdiscrlist}{DW\-\_AT\-\_discr\-\_list}
-&\livelink{chap:DWATdiscrlistlistofdiscriminantvalues}{List of discriminant values} \\
+&\livelinki{chap:DWATdiscrlistlistofdiscriminantvalues}{List of discriminant values}{list of discriminant values} \\
 \livetarg{chap:DWATdiscrvalue}{DW\-\_AT\-\_discr\-\_value}
-&\livelink{chap:DWATdiscrvaluediscriminantvalue}{Discriminant value} \\
+&\livelinki{chap:DWATdiscrvaluediscriminantvalue}{Discriminant value}{discriminant value} \\
 \livetarg{chap:DWATelemental}{DW\-\_AT\-\_elemental}
-&\livelink{chap:DWATelementalelementalpropertyofasubroutine}{Elemental property of a subroutine} \\
+&\livelinki{chap:DWATelementalelementalpropertyofasubroutine}{Elemental property of a subroutine}{elemental property of a subroutine} \\
 \livetarg{chap:DWATencoding}{DW\-\_AT\-\_encoding}
-&\livelink{chap:DWATencodingencodingofbasetype}{Encoding of base type} \\
+&\livelinki{chap:DWATencodingencodingofbasetype}{Encoding of base type}{encoding of base type} \\
 \livetarg{chap:DWATendianity}{DW\-\_AT\-\_endianity}
-&\livelink{chap:DWATendianityendianityofdata}{Endianity of data} \\
+&\livelinki{chap:DWATendianityendianityofdata}{Endianity of data}{endianity of data} \\
 \livetarg{chap:DWATentrypc}{DW\-\_AT\-\_entry\-\_pc}
-&\livelink{chap:DWATentrypcentryaddressofmoduleinitialization}{Entry address of module initialization}\\
-&\livelink{chap:DWATentrypcentryaddressofsubprogram}{Entry address of subprogram} \\
-&\livelink{chap:DWATentrypcentryaddressofinlinedsubprogram}{Entry address of inlined subprogram}\\
+&\livelinki{chap:DWATentrypcentryaddressofmoduleinitialization}{Entry address of module initialization}{entry address of module initialization}\\
+&\livelinki{chap:DWATentrypcentryaddressofsubprogram}{Entry address of subprogram}{entry address of subprogram} \\
+&\livelinki{chap:DWATentrypcentryaddressofinlinedsubprogram}{Entry address of inlined subprogram}{entry address of inlined subprogram}\\
 \livetarg{chap:DWATenumclass}{DW\-\_AT\-\_enum\-\_class}
-&\livelink{chap:DWATenumclasstypesafeenumerationdefinition}{Type safe enumeration definition}\\
+&\livelinki{chap:DWATenumclasstypesafeenumerationdefinition}{Type safe enumeration definition}{type safe enumeration definition}\\
 \livetarg{chap:DWATexplicit}{DW\-\_AT\-\_explicit}
-&\livelink{chap:DWATexplicitexplicitpropertyofmemberfunction}{Explicit property of member function}\\
+&\livelinki{chap:DWATexplicitexplicitpropertyofmemberfunction}{Explicit property of member function}{explicit property of member function}\\
 \livetarg{chap:DWATextension}{DW\-\_AT\-\_extension}
-&\livelink{chap:DWATextensionpreviousnamespaceextensionororiginalnamespace}{Previous namespace extension or original namespace}\\
+&\livelinki{chap:DWATextensionpreviousnamespaceextensionororiginalnamespace}{Previous namespace extension or original namespace}{previous namespace extension or original namespace}\\
 \livetarg{chap:DWATexternal}{DW\-\_AT\-\_external}
-&\livelink{chap:DWATexternalexternalsubroutine}{External subroutine} \\
-&\livelink{chap:DWATexternalexternalvariable}{External variable} \\
+&\livelinki{chap:DWATexternalexternalsubroutine}{External subroutine}{external subroutine} \\
+&\livelinki{chap:DWATexternalexternalvariable}{External variable}{external variable} \\
 \livetarg{chap:DWATframebase}{DW\-\_AT\-\_frame\-\_base}
-&\livelink{chap:DWATframebasesubroutineframebaseaddress}{Subroutine frame base address} \\
+&\livelinki{chap:DWATframebasesubroutineframebaseaddress}{Subroutine frame base address}{subroutine frame base address} \\
 \livetarg{chap:DWATfriend}{DW\-\_AT\-\_friend}
-&\livelink{chap:DWATfriendfriendrelationship}{Friend relationship} \\
+&\livelinki{chap:DWATfriendfriendrelationship}{Friend relationship}{friend relationship} \\
 \livetarg{chap:DWAThighpc}{DW\-\_AT\-\_high\-\_pc}
-&\livelink{chap:DWAThighpccontinguousrangeofcodeaddresses}{Contiguous range of code addresses} \\
+&\livelinki{chap:DWAThighpccontinguousrangeofcodeaddresses}{Contiguous range of code addresses}{contiguous range of code addresses} \\
 \livetarg{chap:DWATidentifiercase}{DW\-\_AT\-\_identifier\-\_case}
-&\livelink{chap:DWATidentifiercaseidentifiercaserule}{Identifier case rule} \\
+&\livelinki{chap:DWATidentifiercaseidentifiercaserule}{Identifier case rule}{identifier case rule} {identifier case rule}{identifier case rule}\\
 \livetarg{chap:DWATimport}{DW\-\_AT\-\_import}
-&\livelink{chap:DWATimportimporteddeclaration}{Imported declaration} \\
-&\livelink{chap:DWATimportimportedunit}{Imported unit} \\
-&\livelink{chap:DWATimportnamespacealias}{Namespace alias} \\
-&\livelink{chap:DWATimportnamespaceusingdeclaration}{Namespace using declaration} \\
-&\livelink{chap:DWATimportnamespaceusingdirective}{Namespace using directive} \\
+&\livelinki{chap:DWATimportimporteddeclaration}{Imported declaration}{imported declaration} \\
+&\livelinki{chap:DWATimportimportedunit}{Imported unit}{imported unit} \\
+&\livelinki{chap:DWATimportnamespacealias}{Namespace alias}{namespace alias} \\
+&\livelinki{chap:DWATimportnamespaceusingdeclaration}{Namespace using declaration}{namespace using declaration} \\
+&\livelinki{chap:DWATimportnamespaceusingdirective}{Namespace using directive}{namespace using directive} \\
 \livetarg{chap:DWATinline}{DW\-\_AT\-\_inline}
-&\livelink{chap:DWATinlineabstracttinstance}{Abstract instance} \\
-&\livelink{chap:DWATinlineinlinedsubroutine}{Inlined subroutine} \\
+&\livelinki{chap:DWATinlineabstracttinstance}{Abstract instance}{abstract instance} \\
+&\livelinki{chap:DWATinlineinlinedsubroutine}{Inlined subroutine}{inlined subroutine} \\
 \livetarg{chap:DWATisoptional}{DW\-\_AT\-\_is\-\_optional}
-&\livelink{chap:DWATisoptionaloptionalparameter}{Optional parameter} \\
+&\livelinki{chap:DWATisoptionaloptionalparameter}{Optional parameter}{optional parameter} \\
 \livetarg{chap:DWATlanguage}{DW\-\_AT\-\_language}
-&\livelink{chap:DWATlanguageprogramminglanguage}{Programming language} \\
+&\livelinki{chap:DWATlanguageprogramminglanguage}{Programming language}{programming language} \\
 \livetarg{chap:DWATlinkagename}{DW\-\_AT\-\_linkage\-\_name}
-&\livelink{chap:DWATlinkagenameobjectfilelinkagenameofanentity}{Object file linkage name of an entity}\\
+&\livelinki{chap:DWATlinkagenameobjectfilelinkagenameofanentity}{Object file linkage name of an entity}{object file linkage name of an entity}\\
 \livetarg{chap:DWATlocation}{DW\-\_AT\-\_location}
-&\livelink{chap:DWATlocationdataobjectlocation}{Data object location}\\
+&\livelinki{chap:DWATlocationdataobjectlocation}{Data object location}{data object location}\\
 \livetarg{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc}
-&\livelink{chap:DWATlowpccodeaddressorrangeofaddresses}{Code address or range of addresses}\\
+&\livelinki{chap:DWATlowpccodeaddressorrangeofaddresses}{Code address or range of addresses}{code address or range of addresses}\\
 \livetarg{chap:DWATlowerbound}{DW\-\_AT\-\_lower\-\_bound}
-&\livelink{chap:DWATlowerboundlowerboundofsubrange}{Lower bound of subrange} \\
+&\livelinki{chap:DWATlowerboundlowerboundofsubrange}{Lower bound of subrange}{lower bound of subrange} \\
 \livetarg{chap:DWATmacroinfo}{DW\-\_AT\-\_macro\-\_info}
-&\livelink{chap:DWATmacroinfomacroinformation}{Macro information} (\#define, \#undef)\\
+&\livelinki{chap:DWATmacroinfomacroinformation}{Macro information} {macro information} (\#define, \#undef)\\
 \livetarg{chap:DWATmainsubprogram}{DW\-\_AT\-\_main\-\_subprogram}
-&\livelink{chap:DWATmainsubprogrammainorstartingsubprogram}{Main or starting subprogram} \\
-&\livelink{chap:DWATmainsubprogramunitcontainingmainorstartingsubprogram}{Unit containing main or starting subprogram}\\
+&\livelinki{chap:DWATmainsubprogrammainorstartingsubprogram}{Main or starting subprogram}{main or starting subprogram} \\
+&\livelinki{chap:DWATmainsubprogramunitcontainingmainorstartingsubprogram}{Unit containing main or starting subprogram}{unit containing main or starting subprogram}\\
 \livetarg{chap:DWATmutable}{DW\-\_AT\-\_mutable}
-&\livelink{chap:DWATmutablemutablepropertyofmemberdata}{Mutable property of member data} \\
+&\livelinki{chap:DWATmutablemutablepropertyofmemberdata}{Mutable property of member data}{mutable property of member data} \\
 \livetarg{chap:DWATname}{DW\-\_AT\-\_name}
-&\livelink{chap:DWATnamenameofdeclaration}{Name of declaration}\\
-&\livelink{chap:DWATnamepathnameofcompilationsource}{Path name of compilation source} \\
+&\livelinki{chap:DWATnamenameofdeclaration}{Name of declaration}{name of declaration}\\
+&\livelinki{chap:DWATnamepathnameofcompilationsource}{Path name of compilation source}{path name of compilation source} \\
 \livetarg{chap:DWATnamelistitem}{DW\-\_AT\-\_namelist\-\_item}
-&\livelink{chap:DWATnamelistitemnamelistitem}{Namelist item}\\
+&\livelinki{chap:DWATnamelistitemnamelistitem}{Namelist item}{namelist item}\\
 \livetarg{chap:DWATobjectpointer}{DW\-\_AT\-\_object\-\_pointer}
-&\livelink{chap:DWATobjectpointerobjectthisselfpointerofmemberfunction}{Object (this, self) pointer of member function}\\
+&\livelinki{chap:DWATobjectpointerobjectthisselfpointerofmemberfunction}{Object (this, self) pointer of member function}{object (this, self) pointer of member function}\\
 \livetarg{chap:DWATordering}{DW\-\_AT\-\_ordering}
-&\livelink{chap:DWATorderingarrayrowcolumnordering}{Array row/column ordering} \\
+&\livelinki{chap:DWATorderingarrayrowcolumnordering}{Array row/column ordering} {array row/column ordering}\\
 \livetarg{chap:DWATpicturestring}{DW\-\_AT\-\_picture\-\_string}
-&\livelink{chap:DWATpicturestringpicturestringfornumericstringtype}{Picture string for numeric string type} \\
+&\livelinki{chap:DWATpicturestringpicturestringfornumericstringtype}{Picture string for numeric string type}{picture string for numeric string type} \\
 \livetarg{chap:DWATpriority}{DW\-\_AT\-\_priority}
-&\livelink{chap:DWATprioritymodulepriority}{Module priority}\\
+&\livelinki{chap:DWATprioritymodulepriority}{Module priority}{module priority}\\
 \livetarg{chap:DWATproducer}{DW\-\_AT\-\_producer}
-&\livelink{chap:DWATproducercompileridentification}{Compiler identification}\\
+&\livelinki{chap:DWATproducercompileridentification}{Compiler identification}{compiler identification}\\
 \livetarg{chap:DWATprototyped}{DW\-\_AT\-\_prototyped}
-&\livelink{chap:DWATprototypedsubroutineprototype}{Subroutine prototype}\\
+&\livelinki{chap:DWATprototypedsubroutineprototype}{Subroutine prototype}{subroutine prototype}\\
 \livetarg{chap:DWATpure}{DW\-\_AT\-\_pure}
-&\livelink{chap:DWATpurepurepropertyofasubroutine}{Pure property of a subroutine} \\
+&\livelinki{chap:DWATpurepurepropertyofasubroutine}{Pure property of a subroutine}{pure property of a subroutine} \\
 \livetarg{chap:DWATranges}{DW\-\_AT\-\_ranges}
-&\livelink{chap:DWATrangesnoncontiguousrangeofcodeaddresses}{Non-contiguous range of code addresses} \\
+&\livelinki{chap:DWATrangesnoncontiguousrangeofcodeaddresses}{Non-contiguous range of code addresses}{non-contiguous range of code addresses} \\
 \livetarg{chap:DWATrecursive}{DW\-\_AT\-\_recursive}
-&\livelink{chap:DWATrecursiverecursivepropertyofasubroutine}{Recursive property of a subroutine} \\
+&\livelinki{chap:DWATrecursiverecursivepropertyofasubroutine}{Recursive property of a subroutine}{recursive property of a subroutine} \\
 \livetarg{chap:DWATreturnaddr}{DW\-\_AT\-\_return\-\_addr}
-&\livelink{chap:DWATreturnaddrsubroutinereturnaddresssavelocation}{Subroutine return address save location} \\
+&\livelinki{chap:DWATreturnaddrsubroutinereturnaddresssavelocation}{Subroutine return address save location}{subroutine return address save location} \\
 \livetarg{chap:DWATsegment}{DW\-\_AT\-\_segment}
-&\livelink{chap:DWATsegmentaddressinginformation}{Addressing information} \\
+&\livelinki{chap:DWATsegmentaddressinginformation}{Addressing information}{addressing information} \\
 \livetarg{chap:DWATsibling}{DW\-\_AT\-\_sibling}
-&\livelink{chap:DWATsiblingdebugginginformationentryrelationship}{Debugging information entry relationship} \\
+&\livelinki{chap:DWATsiblingdebugginginformationentryrelationship}{Debugging information entry relationship}{debugging information entry relationship} \\
 \livetarg{chap:DWATsmall}{DW\-\_AT\-\_small}
-&\livelink{chap:DWATsmallscalefactorforfixedpointtype}{Scale factor for fixed-point type} \\
+&\livelinki{chap:DWATsmallscalefactorforfixedpointtype}{Scale factor for fixed-point type}{scale factor for fixed-point type} \\
 \livetarg{chap:DWATsignature}{DW\-\_AT\-\_signature}
-&\livelink{chap:DWATsignaturetypesignature}{Type signature}\\
+&\livelinki{chap:DWATsignaturetypesignature}{Type signature}{type signature}\\
 \livetarg{chap:DWATspecification}{DW\-\_AT\-\_specification}
-&\livelink{chap:DWATspecificationincompletenondefiningorseparatedeclaration}{Incomplete, non-defining, or separate declaration corresponding to a declaration } \\
+&\livelinki{chap:DWATspecificationincompletenondefiningorseparatedeclaration}{Incomplete, non-defining, or separate declaration corresponding to a declaration}{incomplete, non-defining, or separate declaration corresponding to a declaration} \\
 \livetarg{chap:DWATstartscope}{DW\-\_AT\-\_start\-\_scope}
-&\livelink{chap:DWATstartscopeobjectdeclaration}{Object declaration}\\
-&\livelink{chap:DWATstartscopetypedeclaration}{Type declaration}\\
+&\livelinki{chap:DWATstartscopeobjectdeclaration}{Object declaration}{object declaration}\\
+&\livelinki{chap:DWATstartscopetypedeclaration}{Type declaration}{type declaration}\\
 \livetarg{chap:DWATstaticlink}{DW\-\_AT\-\_static\-\_link}
-&\livelink{chap:DWATstaticlinklocationofuplevelframe}{Location of uplevel frame} \\
+&\livelinki{chap:DWATstaticlinklocationofuplevelframe}{Location of uplevel frame}{location of uplevel frame} \\
 \livetarg{chap:DWATstmtlist}{DW\-\_AT\-\_stmt\-\_list}
-&\livelink{chap:DWATstmtlistlinenumberinformationforunit}{Line number information for unit}\\
+&\livelinki{chap:DWATstmtlistlinenumberinformationforunit}{Line number information for unit}{line number information for unit}\\
 \livetarg{chap:DWATstringlength}{DW\-\_AT\-\_string\-\_length}
-&\livelink{chap:DWATstringlengthstringlengthofstringtype}{String length of string type} \\
+&\livelinki{chap:DWATstringlengthstringlengthofstringtype}{String length of string type}{string length of string type}
+ \\
 \livetarg{chap:DWATthreadsscaled}{DW\-\_AT\-\_threads\-\_scaled}
 &\livelink{chap:DWATthreadsscaledupcarrayboundthreadsscalfactor}{UPC array bound THREADS scale factor}\\
 \livetarg{chap:DWATtrampoline}{DW\-\_AT\-\_trampoline}
-&\livelink{chap:DWATtrampolinetargetsubroutine}{Target subroutine} \\
+&\livelinki{chap:DWATtrampolinetargetsubroutine}{Target subroutine}{target subroutine of trampoline} \\
 \livetarg{chap:DWATtype}{DW\-\_AT\-\_type}
-&\livelink{chap:DWATtypetypeofdeclaration}{Type of declaration} \\
-&\livelink{chap:DWATtypetypeofsubroutinereturn}{Type of subroutine return} \\
+&\livelinki{chap:DWATtypetypeofdeclaration}{Type of declaration}{type of declaration} \\
+&\livelinki{chap:DWATtypetypeofsubroutinereturn}{Type of subroutine return}{type of subroutine return} \\
 \livetarg{chap:DWATupperbound}{DW\-\_AT\-\_upper\-\_bound}
-&\livelink{chap:DWATupperboundupperboundofsubrange}{Upper bound of subrange} \\
+&\livelinki{chap:DWATupperboundupperboundofsubrange}{Upper bound of subrange}{upper bound of subrange} \\
 \livetarg{chap:DWATuselocation}{DW\-\_AT\-\_use\-\_location}
-&\livelink{chap:DWATuselocationmemberlocationforpointertomembertype}{Member location for pointer to member type} \\
+&\livelinki{chap:DWATuselocationmemberlocationforpointertomembertype}{Member location for pointer to member type}{member location for pointer to member type} \\
 \livetarg{chap:DWATuseUTF8}{DW\-\_AT\-\_use\-\_UTF8}
-&\livelink{chap:DWATuseUTF8compilationunitusesutf8strings}{Compilation unit uses UTF-8 strings} \\
+&\livelinki{chap:DWATuseUTF8compilationunitusesutf8strings}{Compilation unit uses UTF-8 strings}{compilation unit uses UTF-8 strings} \\
 \livetarg{chap:DWATvariableparameter}{DW\-\_AT\-\_variable\-\_parameter}
-&\livelink{chap:DWATvariableparameternonconstantparameterflag}{Non-constant parameter flag}  \\
+&\livelinki{chap:DWATvariableparameternonconstantparameterflag}{Non-constant parameter flag}{non-constant parameter flag}  \\
 \livetarg{chap:DWATvirtuality}{DW\-\_AT\-\_virtuality}
-&\livelink{chap:DWATvirtualityvirtualityindication}{Virtuality indication} \\
-&\livelink{chap:DWATvirtualityvirtualityofbaseclass}{Virtuality of base class} \\
-&\livelink{chap:DWATvirtualityvirtualityoffunction}{Virtuality of function} \\
+&\livelinki{chap:DWATvirtualityvirtualityindication}{Virtuality indication}{virtuality indication} \\
+&\livelinki{chap:DWATvirtualityvirtualityofbaseclass}{Virtuality of base class} {virtuality of base class} \\
+&\livelinki{chap:DWATvirtualityvirtualityoffunction}{Virtuality of function}{virtuality of function} \\
 \livetarg{chap:DWATvisibility}{DW\-\_AT\-\_visibility}
-&\livelink{chap:DWATvisibilityvisibilityofdeclaration}{Visibility of declaration} \\
+&\livelinki{chap:DWATvisibilityvisibilityofdeclaration}{Visibility of declaration}{visibility of declaration} \\
 \livetarg{chap:DWATvtableelemlocation}{DW\-\_AT\-\_vtable\-\_elem\-\_location}
-&\livelink{chap:DWATvtableelemlocationvirtualfunctiontablevtableslot}{Virtual function vtable slot}\\
+&\livelinki{chap:DWATvtableelemlocationvirtualfunctiontablevtableslot}{Virtual function vtable slot}{virtual function vtable slot}\\
 \end{longtable}
 
 \begin{figure}[here]
@@ -374,8 +386,8 @@ Attribute Class & General Use and Encoding \\ \hline
  \\
 \livetargi{chap:constant}{constant}{constant class}
 &One, two, four or eight bytes of uninterpreted data, or data
-encoded in the variable length format known as LEB128 (see
-Section 7.6.).
+encoded in the variable length format known as LEB128 
+(see Section \refersec{datarep:variablelengthdata}).
 
 \textit{Most constant values are integers of one kind or
 another (codes, offsets, counts, and so on); these are
@@ -426,8 +438,9 @@ string table.
 \clearpage
 \section{Relationship of Debugging Information Entries}
 \label{chap:relationshipofdebugginginformationentries}
-\textit{
+\textit{%
 A variety of needs can be met by permitting a single
+\addtoindexx{debugging information entry!ownership relation}
 debugging information entry to “own” an arbitrary number
 of other debugging entries and by permitting the same debugging
 information entry to be one of many owned by another debugging
@@ -441,7 +454,9 @@ with shared objects.
 }
 
 
-The ownership relation of debugging
+The ownership relation 
+\addtoindexx{debugging information entry!ownership relation}
+of debugging
 information entries is achieved naturally because the debugging
 information is represented as a tree. 
 The nodes of the tree
@@ -450,7 +465,7 @@ The child
 entries of any node are exactly those debugging information
 entries owned by that node.  
 
-\textit{
+\textit{%
 While the ownership relation
 of the debugging information entries is represented as a
 tree, other relations among the entries exist, for example,
@@ -465,7 +480,7 @@ The tree itself is represented
 by flattening it in prefix order. 
 Each debugging information
 entry is defined either to have child entries or not to have
-child entries (see Section 7.5.3). 
+child entries (see Section \refersec{datarep:abbreviationstables}). 
 If an entry is defined not
 to have children, the next physically succeeding entry is a
 sibling. 
@@ -479,8 +494,11 @@ In cases where a producer of debugging information feels that
 \hypertarget{chap:DWATsiblingdebugginginformationentryrelationship}
 it will be important for consumers of that information to
 quickly scan chains of sibling entries, while ignoring the
-children of individual siblings, that producer may attach a
-\livelink{chap:DWATsibling}{DW\-\_AT\-\_sibling} attribute to any debugging information entry. 
+children of individual siblings, that producer may attach 
+\addtoindexx{sibling attribute}
+a
+\livelink{chap:DWATsibling}{DW\-\_AT\-\_sibling} attribute 
+to any debugging information entry. 
 The
 value of this attribute is a reference to the sibling entry
 of the entry to which the attribute is attached.
@@ -492,7 +510,6 @@ Many places in this document
 refer
 \addtoindexx{address size|see{size of an address}}
 to the size 
-\addtoindexx{address!size of an|see{size of an address}}
 of an
 \addtoindexi{address}{size of an address}
 on the target architecture (or equivalently, target machine)
@@ -503,24 +520,23 @@ which is either the default for that processor or which is
 specified by the object file or executable file which contains
 the DWARF information.
 
-
-
-\textit{
+\textit{%
 For example, if a particular target architecture supports
 both 32\dash bit and 64\dash bit addresses, the compiler will generate
 an object file which specifies that it contains executable
-code generated for one or the other of these address sizes. In
+code generated for one or the other of these 
+\addtoindexx{size of an address}
+address sizes. In
 that case, the DWARF debugging information contained in this
 object file will use the same address size.
 }
 
-\textit{
+\textit{%
 Architectures which have multiple instruction sets are
 supported by the isa entry in the line number information
 (see Section \refersec{chap:statemachineregisters}).
 }
 
-
 \section{DWARF Expressions}
 \label{chap:dwarfexpressions}
 DWARF expressions describe how to compute a value or name a
@@ -536,22 +552,30 @@ of operands is determined by the opcode.
 In addition to the
 general operations that are defined here, operations that are
 specific to location descriptions are defined in 
-Section \refersec{chap:locationdescriptions} .
+Section \refersec{chap:locationdescriptions}.
 
 \subsection{General Operations}
 \label{chap:generaloperations}
 Each general operation represents a postfix operation on
 a simple stack machine. Each element of the stack is the
-size of an address on the target machine. The value on the
-top of the stack after ``executing'' the DWARF expression
-is taken to be the result (the address of the object, the
+\addtoindex{size of an address} on the target machine. 
+The value on the
+top of the stack after ``executing'' the 
+\addtoindex{DWARF expression}
+is 
+\addtoindex{DWARF expression|see{location description}}
+taken to be the result (the address of the object, the
 value of the array bound, the length of a dynamic string,
 the desired value itself, and so on).
 
 \subsubsection{Literal Encodings}
 \label{chap:literalencodings}
-The following operations all push a value onto the DWARF
-stack. If the value of a constant in one of these operations
+The 
+\addtoindexx{DWARF expression!literal encodings}
+following operations all push a value onto the DWARF
+stack. 
+\addtoindexx{DWARF expression!stack operations}
+If the value of a constant in one of these operations
 is larger than can be stored in a single stack element, the
 value is truncated to the element size and the low\dash order bits
 are pushed on the stack.
@@ -563,7 +587,7 @@ from 0 through 31, inclusive.
 
 \item \livetarg{chap:DWOPaddr}{DW\-\_OP\-\_addr} \\
 The \livelink{chap:DWOPaddr}{DW\-\_OP\-\_addr} operation has a single operand that encodes
-a machine address and whose size is the size of an address
+a machine address and whose size is the \addtoindex{size of an address}
 on the target machine.
 
 \item \livetarg{chap:DWOPconst1u}{DW\-\_OP\-\_const1u}, \livetarg{chap:DWOPconst2u}{DW\-\_OP\-\_const2u}, \livetarg{chap:DWOPconst4u}{DW\-\_OP\-\_const4u}, \livetarg{chap:DWOPconst8u}{DW\-\_OP\-\_const8u} \\
@@ -588,6 +612,7 @@ a signed LEB128 integer constant.
 \subsubsection{Register Based Addressing}
 \label{chap:registerbasedaddressing}
 The following operations push a value onto the stack that is
+\addtoindexx{DWARF expression!register based addressing}
 the result of adding the contents of a register to a given
 signed offset.
 
@@ -618,7 +643,9 @@ a signed LEB128 offset.
 
 \subsubsection{Stack Operations}
 \label{chap:stackoperations}
-The following operations manipulate the DWARF stack. Operations
+The following 
+\addtoindexx{DWARF expression!stack operations}
+operations manipulate the DWARF stack. Operations
 that index the stack assume that the top of the stack (most
 recently added entry) has index 0.
 
@@ -661,7 +688,7 @@ treats it as an address. The value
 retrieved from that address is pushed. 
 The size of the data retrieved from the 
 \addtoindexi{dereferenced}{address!dereference operator}
-address is the size of an address on the target machine.
+address is the \addtoindex{size of an address} on the target machine.
 
 \item \livetarg{chap:DWOPderefsize}{DW\-\_OP\-\_deref\-\_size} \\
 The \livelink{chap:DWOPderefsize}{DW\-\_OP\-\_deref\-\_size} operation behaves like the \livelink{chap:DWOPderef}{DW\-\_OP\-\_deref}
@@ -671,7 +698,7 @@ the \livelink{chap:DWOPderefsize}{DW\-\_OP\-\_deref\-\_size} operation, however,
 of the data retrieved from the dereferenced address is
 specified by the single operand. This operand is a 1\dash byte
 unsigned integral constant whose value may not be larger
-than the size of an address on the target machine. The data
+than the \addtoindex{size of an address} on the target machine. The data
 retrieved is zero extended to the size of an address on the
 target machine before being pushed onto the expression stack.
 
@@ -687,7 +714,7 @@ address calculation and pushed as the new stack top. The size
 of the data retrieved from the 
 \addtoindexi{dereferenced}{address!dereference operator}
 address is the
-size of an address on the target machine.
+\addtoindex{size of an address} on the target machine.
 
 \item \livetarg{chap:DWOPxderefsize}{DW\-\_OP\-\_xderef\-\_size}\\
 The \livelink{chap:DWOPxderefsize}{DW\-\_OP\-\_xderef\-\_size} operation behaves like the
@@ -704,8 +731,8 @@ the size in bytes of the data retrieved from the
 \addtoindexi{dereferenced}{address!dereference operator}
 address is specified by the single operand. This operand is a
 1\dash byte unsigned integral constant whose value may not be larger
-than the size of an address on the target machine. The data
-retrieved is zero extended to the size of an address on the
+than the \addtoindex{size of an address} on the target machine. The data
+retrieved is zero extended to the \addtoindex{size of an address} on the
 target machine before being pushed onto the expression stack.
 
 \item \livetarg{chap:DWOPpushobjectaddress}{DW\-\_OP\-\_push\-\_object\-\_address}\\
@@ -735,7 +762,8 @@ 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 C and C++ support a
+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
 as automatic variables have distinct values and addresses in
@@ -764,12 +792,18 @@ space efficient to reference that.
 \end{enumerate}
 
 \subsubsection{Arithmetic and Logical Operations}
-The following provide arithmetic and logical operations. Except
+The 
+\addtoindexx{DWARF expression!arithmetic operations}
+following 
+\addtoindexx{DWARF expression!logical operations}
+provide arithmetic and logical operations. Except
 as otherwise specified, the arithmetic operations perfom
 addressing arithmetic, that is, unsigned arithmetic that is
 performed modulo one plus the largest representable address
-(for example, 0x100000000 when the size of an address is 32
-bits). Such operations do not cause an exception on overflow.
+(for example, 0x100000000 when the 
+\addtoindex{size of an address} is 32
+bits). 
+Such operations do not cause an exception on overflow.
 
 \begin{enumerate}[1]
 \item \livetarg{chap:DWOPabs}{DW\-\_OP\-\_abs}  \\
@@ -819,7 +853,7 @@ The \livelink{chap:DWOPplusuconst}{DW\-\_OP\-\_plus\-\_uconst} operation pops th
 adds it to the unsigned LEB128 constant operand and pushes
 the result.  This operation is supplied specifically to be
 able to encode more field offsets in two bytes than can be
-done with “\livelink{chap:DWOPlit}{DW\-\_OP\-\_litn}n \livelink{chap:DWOPplus}{DW\-\_OP\-\_plus}”.
+done with “\livelink{chap:DWOPlit}{DW\-\_OP\-\_lit\textit{n}} \livelink{chap:DWOPplus}{DW\-\_OP\-\_plus}”.
 
 \item \livetarg{chap:DWOPshl}{DW\-\_OP\-\_shl} \\
 The \livelink{chap:DWOPshl}{DW\-\_OP\-\_shl} operation pops the top two stack entries,
@@ -849,7 +883,9 @@ pushes the result.
 
 \subsubsection{Control Flow Operations}
 \label{chap:controlflowoperations}
-The following operations provide simple control of the flow of a DWARF expression.
+The 
+\addtoindexx{DWARF expression!control flow operations}
+following operations provide simple control of the flow of a DWARF expression.
 \begin{enumerate}[1]
 \item  \livetarg{chap:DWOPle}{DW\-\_OP\-\_le}, \livetarg{chap:DWOPge}{DW\-\_OP\-\_ge}, \livetarg{chap:DWOPeq}{DW\-\_OP\-\_eq}, \livetarg{chap:DWOPlt}{DW\-\_OP\-\_lt}, \livetarg{chap:DWOPgt}{DW\-\_OP\-\_gt}, \livetarg{chap:DWOPne}{DW\-\_OP\-\_ne} \\
 The six relational operators each:
@@ -902,7 +938,10 @@ unit. The \livelink{chap:DWOPcallref}{DW\-\_OP\-\_call\-\_ref} operator has a si
 in the 64\dash bit DWARF format, it is an 8\dash byte unsigned value
 (see Section \refersec{datarep:32bitand64bitdwarfformats}). 
 The operand is used as the offset of a
-debugging information entry in a .debug\_info or .debug\_types
+debugging information entry in a 
+\addtoindex{.debug\_info}
+or
+\addtoindex{.debug\_types}
 section which may be contained in a shared object or executable
 other than that containing the operator. For references from
 one shared object or executable to another, the relocation
@@ -916,11 +955,16 @@ respectively
 }
 
 These operations transfer
-control of DWARF expression evaluation to the 
+control of DWARF expression evaluation to 
+\addtoindexx{location attribute}
+the 
 \livelink{chap:DWATlocation}{DW\-\_AT\-\_location}
 attribute of the referenced debugging information entry. If
 there is no such attribute, then there is no effect. Execution
-of the DWARF expression of a \livelink{chap:DWATlocation}{DW\-\_AT\-\_location} attribute may add
+of the DWARF expression of 
+\addtoindexx{location attribute}
+a 
+\livelink{chap:DWATlocation}{DW\-\_AT\-\_location} attribute may add
 to and/or remove from values on the stack. Execution returns
 to the point following the call when the end of the attribute
 is reached. Values on the stack at the time of the call may be
@@ -931,7 +975,9 @@ by prior agreement between the calling and called expressions.
 
 
 \subsubsection{Special Operations}
-There is one special operation currently defined:
+There 
+\addtoindexx{DWARF expression!special operations}
+is one special operation currently defined:
 \begin{enumerate}[1]
 \item \livetarg{chap:DWOPnop}{DW\-\_OP\-\_nop} \\
 The \livelink{chap:DWOPnop}{DW\-\_OP\-\_nop} operation is a place holder. It has no effect
@@ -939,7 +985,9 @@ on the location stack or any of its values.
 
 \end{enumerate}
 \subsection{Example Stack Operations}
-\textit {The stack operations defined in 
+\textit {The 
+\addtoindexx{DWARF expression!examples}
+stack operations defined in 
 Section \refersec{chap:stackoperations}.
 are fairly conventional, but the following
 examples illustrate their behavior graphically.
@@ -982,7 +1030,13 @@ examples illustrate their behavior graphically.
 
 \section{Location Descriptions}
 \label{chap:locationdescriptions}
-\textit{ Debugging information must provide consumers a way to find
+\textit{Debugging information 
+\addtoindexx{location description}
+\addtoindexx{location description}
+must 
+%FIXME: should be 'see also' somehow.
+\addtoindexx{location description|see{DWARF expression}}
+provide consumers a way to find
 the location of program variables, determine the bounds
 of dynamic arrays and strings, and possibly to find the
 base address of a subroutine’s stack frame or the return
@@ -995,9 +1049,14 @@ Information about the location of program objects is provided
 by location descriptions. Location descriptions can be either
 of two forms:
 \begin{enumerate}[1]
-\item \textit{Single location descriptions}, which are a language independent representation of
+\item \textit{Single location descriptions}, 
+which 
+\addtoindexx{location description!single}
+are 
+\addtoindexx{single location description}
+a language independent representation of
 addressing rules of arbitrary complexity built from 
-DWARF expressions (See section \refersec{chap:dwarfexpressions}) 
+DWARF expressions (See Section \refersec{chap:dwarfexpressions}) 
 and/or other
 DWARF operations specific to describing locations. They are
 sufficient for describing the location of any object as long
@@ -1008,18 +1067,23 @@ and it does not move during its lifetime.
 Single location descriptions are of two kinds:
 \begin{enumerate}[a]
 \item Simple location descriptions, which describe the location
+\addtoindexx{location description!simple}
 of one contiguous piece (usually all) of an object. A simple
 location description may describe a location in addressable
 memory, or in a register, or the lack of a location (with or
 without a known value).
 
 \item  Composite location descriptions, which describe an
+\addtoindexx{location description!composite}
 object in terms of pieces each of which may be contained in
 part of a register or stored in a memory location unrelated
 to other pieces.
 
 \end{enumerate}
-\item \textit{Location lists}, which are used to describe
+\item \textit{Location lists}, which are used to 
+\addtoindexx{location list}
+describe
+\addtoindexx{location description!use in location list}
 objects that have a limited lifetime or change their location
 during their lifetime. Location lists are more completely
 described below.
@@ -1028,10 +1092,17 @@ described below.
 
 The two forms are distinguished in a context sensitive
 manner. As the value of an attribute, a location description
-is encoded using class \livelink{chap:exprloc}{exprloc}  
+is encoded using 
+\addtoindexx{exprloc class}
+class \livelink{chap:exprloc}{exprloc}  
 and a location list is encoded
-using class \livelink{chap:loclistptr}{loclistptr} (which serves as an offset into a
-separate location list table).
+using class \livelink{chap:loclistptr}{loclistptr}
+(which 
+\addtoindex{loclistptr}
+serves as an offset into a
+separate 
+\addtoindexx{location list}
+location list table).
 
 
 \subsection{Single Location Descriptions}
@@ -1039,8 +1110,12 @@ A single location description is either:
 
 \begin{enumerate}[1]
 \item A simple location description, representing an object
-which exists in one contiguous piece at the given location, or 
+\addtoindexx{location description!simple}
+which 
+\addtoindexx{simple location description}
+exists in one contiguous piece at the given location, or 
 \item A composite location description consisting of one or more
+\addtoindexx{location description!composite}
 simple location descriptions, each of which is followed by
 one composition operation. Each simple location description
 describes the location of one piece of the object; each
@@ -1054,13 +1129,19 @@ DWARF expression is evaluated independently of any others
 
 \subsubsection{Simple Location Descriptions}
 
-A simple location description consists of one 
+A 
+\addtoindexx{location description!simple}
+simple location description consists of one 
 contiguous piece or all of an object or value.
 
 
 \paragraph{Memory Location Descriptions}
 
-A memory location description consists of a non\dash empty DWARF
+A 
+\addtoindexx{location description!memory}
+memory location description 
+\addtoindexx{memory location description}
+consists of a non\dash empty DWARF
 expression (see 
 Section \refersec{chap:dwarfexpressions}
 ), whose value is the address of
@@ -1113,7 +1194,9 @@ one of the register based addressing operations, such as
 
 \paragraph{Implicit Location Descriptions}
 
-An implicit location description represents a piece or all
+An \addtoindex{implicit location description}
+represents a piece or all
+\addtoindexx{location description!implicit}
 of an object which has no actual location but whose contents
 are nonetheless either known or known to be undefined.
 
@@ -1146,7 +1229,9 @@ actual value of the object, rather than its location. The
 
 \paragraph{Empty Location Descriptions}
 
-An empty location description consists of a DWARF expression
+An \addtoindex{empty location description}
+consists of a DWARF expression
+\addtoindexx{location description!empty}
 containing no operations. It represents a piece or all of an
 object that is present in the source but not in the object code
 (perhaps due to optimization).
@@ -1167,7 +1252,8 @@ of the resultant value is contained.
 
 \begin{enumerate}[1]
 \item \livetarg{chap:DWOPpiece}{DW\-\_OP\-\_piece} \\
-The \livelink{chap:DWOPpiece}{DW\-\_OP\-\_piece} operation takes a single operand, which is an
+The \livelink{chap:DWOPpiece}{DW\-\_OP\-\_piece} operation takes a 
+single operand, which is an
 unsigned LEB128 number.  The number describes the size in bytes
 of the piece of the object referenced by the preceding simple
 location description. If the piece is located in a register,
@@ -1289,13 +1375,17 @@ contents of r3 and r4.
 
 \subsection{Location Lists}
 \label{chap:locationlists}
-Location lists are used in place of location expressions
+Location lists 
+\addtoindexx{location list}
+are used in place of location expressions
 whenever the object whose location is being described
-can change location during its lifetime. Location lists
+can change location during its lifetime. 
+Location lists
+\addtoindexx{location list}
 are contained in a separate object file section called
-.debug\_loc. A location list is indicated by a location
+\addtoindex{.debug\_loc}. A location list is indicated by a location
 attribute whose value is an offset from the beginning of
-the .debug\_loc section to the first byte of the list for the
+the \addtoindex{.debug\_loc} section to the first byte of the list for the
 object in question.
 
 Each entry in a location list is either a location 
@@ -1303,13 +1393,19 @@ Each entry in a location list is either a location
 entry,
 a 
 \addtoindexi{base}{base address selection entry!in location list} 
-address selection entry, or an end of list entry.
+address selection entry, 
+\addtoindexx{location list!base address selection entry}
+or an 
+\addtoindexx{end of list entry!in location list}
+end of list entry.
 
-A location list entry consists of:
+A 
+\addtoindexx{location list!entry}
+location list entry consists of:
 
 \begin{enumerate}[1]
 \item A beginning address offset. 
-This address offset has the size of an address and is
+This address offset has the \addtoindex{size of an address} and is
 relative to the applicable base address of the compilation
 unit referencing this location list. It marks the beginning
 of the address 
@@ -1317,22 +1413,26 @@ of the address
 over which the location is valid.
 
 \item An ending address offset.  This address offset again
-has the size of an address and is relative to the applicable
+has the \addtoindex{size of an address} and is relative to the applicable
 base address of the compilation unit referencing this location
 list. It marks the first address past the end of the address
 range over which the location is valid. The ending address
 must be greater than or equal to the beginning address.
 
-\textit{A location list entry (but not a base address selection or end of list entry) whose beginning
-and ending addresses are equal has no effect because the size of the range covered by such
+\textit{A location list entry (but not a base address selection or 
+end of list entry) whose beginning
+and ending addresses are equal has no effect 
+because the size of the range covered by such
 an entry is zero.}
 
-\item A single location description 
+\item A \addtoindex{single location description} 
 describing the location of the object over the range specified by
 the beginning and end addresses.
 \end{enumerate}
 
-The applicable base address of a location list entry is
+The applicable base address of a 
+location list entry is
+\addtoindexx{location list!base address selection entry}
 determined by the closest preceding base address selection
 entry (see below) in the same location list. If there is
 no such selection entry, then the applicable base address
@@ -1366,10 +1466,13 @@ and ending address offsets of subsequent entries of the location list.
 \textit{A base address selection entry 
 affects only the list in which it is contained.}
 
-The end of any given location list is marked by an end of
-list entry, which consists of a 0 for the beginning address
+The end of any given location list is marked by an 
+\addtoindexx{location list!enf of list entry}
+end of list entry, which consists of a 0 for the beginning address
 offset and a 0 for the ending address offset. A location list
-containing only an end of list entry describes an object that
+containing only an 
+\addtoindexx{end of list entry!in location list}
+end of list entry describes an object that
 exists in the source code but not in the executable program.
 
 Neither a base address selection entry nor an end of list
@@ -1378,7 +1481,7 @@ entry includes a location description.
 \textit{A base address selection entry and an end of list
 entry for a location list are identical to a base address
 selection entry and end of list entry, respectively, for a
-range list 
+\addtoindex{range list}
 (see Section \refersec{chap:noncontiguousaddressranges}) 
 in interpretation
 and representation.}
@@ -1411,7 +1514,8 @@ base types, user-defined types and type modifiers.
 
 \section{Accessibility of Declarations}
 \label{chap:accessibilityofdeclarations}
-\textit{Some languages, notably C++ and Ada, have the concept of
+\textit{Some languages, notably C++ and 
+\addtoindex{Ada}, have the concept of
 the accessibility of an object or of some other program
 entity. The accessibility specifies which classes of other
 program objects are permitted access to the object in question.}
@@ -1419,7 +1523,9 @@ program objects are permitted access to the object in question.}
 The accessibility of a declaration is 
 \hypertarget{chap:DWATaccessibilitycandadadeclarations}
 represented by a 
-\livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} attribute, whose
+\livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} 
+attribute, whose
+\addtoindexx{accessibility attribute}
 value is a constant drawn from the set of codes listed in Figure 
 \ref{fig:accessibilitycodes}.
 
@@ -1437,7 +1543,7 @@ value is a constant drawn from the set of codes listed in Figure
 \section{Visibility of Declarations}
 \label{chap:visibilityofdeclarations}
 
-\textit{Several languages (such as Modula-2
+\textit{Several languages (such as \addtoindex{Modula-2}
 have the concept of the visibility of a declaration. The
 visibility specifies which declarations are to be 
 visible outside of the entity in which they are
@@ -1446,7 +1552,8 @@ declared.}
 The 
 \hypertarget{chap:DWATvisibilityvisibilityofdeclaration}
 visibility of a declaration is represented 
-by a \livelink{chap:DWATvisibility}{DW\-\_AT\-\_visibility} attribute, whose value is a
+by a \livelink{chap:DWATvisibility}{DW\-\_AT\-\_visibility}
+attribute\addtoindexx{visibility attribute}, whose value is a
 constant drawn from the set of codes listed in 
 Figure \ref{fig:visibilitycodes}.
 
@@ -1469,7 +1576,8 @@ member functions and for virtual base classes.}
 The 
 \hypertarget{chap:DWATvirtualityvirtualityindication}
 virtuality of a declaration is represented by a
-\livelink{chap:DWATvirtuality}{DW\-\_AT\-\_virtuality} attribute, whose value is a constant drawn
+\livelink{chap:DWATvirtuality}{DW\-\_AT\-\_virtuality}
+attribute\addtoindexx{virtuality attribute}, whose value is a constant drawn
 from the set of codes listed in 
 Figure \ref{fig:virtualitycodes}.
 
@@ -1494,6 +1602,7 @@ implementations pass as the first argument to non-static member
 functions.}  
 
 Any debugging information entry representing the
+\addtoindexx{artificial attribute}
 declaration of an object or type artificially generated by
 a compiler and not explicitly declared by the source program
 \hypertarget{chap:DWATartificialobjectsortypesthat}
@@ -1506,7 +1615,9 @@ which is a \livelink{chap:flag}{flag}.
 \textit{In some systems, addresses are specified as offsets within a
 given 
 \addtoindexx{address space!segmented}
-segment rather than as locations within a single flat
+segment 
+\addtoindexx{segmented adddressing|see{address space}}
+rather than as locations within a single flat
 \addtoindexx{address space!flat}.
 address space.}
 
@@ -1514,23 +1625,38 @@ Any debugging information entry that contains a description
 \hypertarget{chap:DWATsegmentaddressinginformation}
 of the location of an object or subroutine may have
 a 
-\livelink{chap:DWATsegment}{DW\-\_AT\-\_segment}
-attribute, whose value is a location
+\livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} attribute, 
+\addtoindexx{segment attribute}
+whose value is a location
 description. The description evaluates to the segment selector
 of the item being described. If the entry containing the
-\livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} attribute has a \livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc}, \livelink{chap:DWAThighpc}{DW\-\_AT\-\_high\-\_pc},
-\livelink{chap:DWATranges}{DW\-\_AT\-\_ranges} or \livelink{chap:DWATentrypc}{DW\-\_AT\-\_entry\-\_pc} attribute, or a location
+\livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} attribute has a 
+\livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc}, 
+\livelink{chap:DWAThighpc}{DW\-\_AT\-\_high\-\_pc},
+\livelink{chap:DWATranges}{DW\-\_AT\-\_ranges} or 
+\livelink{chap:DWATentrypc}{DW\-\_AT\-\_entry\-\_pc} attribute, 
+\addtoindexx{entry pc attribute}
+or 
+a location
 description that evaluates to an address, then those address
 values represent the offset portion of the address within
-the segment specified by \livelink{chap:DWATsegment}{DW\-\_AT\-\_segment}.
+the segment specified 
+\addtoindexx{segment attribute}
+by \livelink{chap:DWATsegment}{DW\-\_AT\-\_segment}.
 
-If an entry has no \livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} attribute, it inherits
+If an entry has no 
+\livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} attribute, it inherits
+\addtoindexx{segment attribute}
 the segment value from its parent entry.  If none of the
 entries in the chain of parents for this entry back to
-its containing compilation unit entry have \livelink{chap:DWATsegment}{DW\-\_AT\-\_segment}
-attributes, then the entry is assumed to exist within a flat
-address space. Similarly, if the entry has a \livelink{chap:DWATsegment}{DW\-\_AT\-\_segment}
-attribute containing an empty location description, that
+its containing compilation unit entry have 
+\livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} attributes, 
+then the entry is assumed to exist within a flat
+address space. 
+Similarly, if the entry has a 
+\livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} attribute 
+\addtoindexx{segment attribute}
+containing an empty location description, that
 entry is assumed to exist within a 
 \addtoindexi{flat}{address space!flat}.
 address space.
@@ -1578,11 +1704,12 @@ A debugging information entry representing a program entity
 typically represents the defining declaration of that
 entity. In certain contexts, however, a debugger might need
 information about a declaration of an entity that is not
+\addtoindexx{incomplete declaration}
 also a definition, or is otherwise incomplete, to evaluate
 \hypertarget{chap:DWATdeclarationincompletenondefiningorseparateentitydeclaration}
 an expression correctly.
 
-\textit{As an example, consider the following fragment of C code:}
+\textit{As an example, consider the following fragment of \addtoindex{C} code:}
 
 \begin{lstlisting}
 void myfunc()
@@ -1596,13 +1723,19 @@ void myfunc()
 \end{lstlisting}
 
 
-\textit{C scoping rules require that the 
+\textit{\addtoindex{C} scoping rules require that the 
 value of the variable x passed to the function g is the value of the
 global variable x rather than of the local version.}
 
 \subsection{Non-Defining Declarations}
-A debugging information entry that represents a non-defining or otherwise incomplete
-declaration of a program entity has a 
+A debugging information entry that 
+represents a non-defining or 
+\addtoindex{non-defining declaration}
+otherwise 
+\addtoindex{incomplete declaration}
+of a program entity has 
+\addtoindexx{declaration attribute}
+a 
 \livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration} 
 attribute, which is a 
 \livelink{chap:flag}{flag}.
@@ -1624,17 +1757,25 @@ It is not the case that all attributes of the debugging information entry refere
 \livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} attribute 
 apply to the referring debugging information entry.
 
-\textit{For example,
+\textit{For 
+\addtoindexx{declaration attribute}
+example,
 \livelink{chap:DWATsibling}{DW\-\_AT\-\_sibling} and 
 \livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration} 
-clearly cannot apply to a referring
+\addtoindexx{declaration attribute}
+clearly cannot apply to a 
+\addtoindexx{declaration attribute}
+referring
+\addtoindexx{sibling attribute}
 entry.}
 
 
 
 \section{Declaration Coordinates}
 \label{chap:declarationcoordinates}
-\textit{It is sometimes useful in a debugger to be able to associate
+\textit{It is 
+\addtoindexx{declaration coordinates}
+sometimes useful in a debugger to be able to associate
 a declaration with its occurrence in the program source.
 }
 
@@ -1645,23 +1786,43 @@ entry
 representing 
 \hypertarget{chap:DWATdeclcolumncolumnpositionofsourcedeclaration}
 the
-declaration of an object, module, subprogram or type may have
-\livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file}, \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} and \livelink{chap:DWATdeclcolumn}{DW\-\_AT\-\_decl\-\_column}
+\addtoindexx{line number of declaration}
+declaration of an object, module, subprogram or
+\addtoindex{declaration column attribute}
+type 
+\addtoindex{declaration file attribute}
+may 
+\addtoindex{declaration line attribute}
+have
+\livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file}, 
+\livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} and 
+\livelink{chap:DWATdeclcolumn}{DW\-\_AT\-\_decl\-\_column}
 attributes each of whose value is an unsigned integer constant.
 
-The value of the \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} attribute corresponds to
+The value of 
+\addtoindex{declaration file attribute}
+the 
+\livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file}
+attribute 
+\addtoindexx{file containing declaration}
+corresponds to
 a file number from the line number information table for the
 compilation unit containing the debugging information entry and
 represents the source file in which the declaration appeared
-(see Section 6.2). The value 0 indicates that no source file
+(see Section \refersec{chap:linenumberinformation}). 
+The value 0 indicates that no source file
 has been specified.
 
-The value of the \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} attribute represents
+The value of 
+\addtoindex{declaration line attribute}
+the \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} attribute represents
 the source line number at which the first character of
 the identifier of the declared object appears. The value 0
 indicates that no source line has been specified.
 
-The value of the \livelink{chap:DWATdeclcolumn}{DW\-\_AT\-\_decl\-\_column} attribute represents
+The value of 
+\addtoindex{declaration column attribute}
+the \livelink{chap:DWATdeclcolumn}{DW\-\_AT\-\_decl\-\_column} attribute represents
 the source column number at which the first character of
 the identifier of the declared object appears. The value 0
 indicates that no column has been specified.
@@ -1670,10 +1831,16 @@ indicates that no column has been specified.
 \label{chap:identifiernames}
 Any 
 \hypertarget{chap:DWATnamenameofdeclaration}
-debugging information entry representing a program entity
+debugging information entry 
+\addtoindexx{identifier names}
+representing 
+\addtoindexx{names!identifier}
+a program entity
 that has been given a name may have a 
 \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
-whose value is a string representing the name as it appears in
+whose 
+\addtoindexx{name attribute}
+value is a string representing the name as it appears in
 the source program. A debugging information entry containing
 no name attribute, or containing a name attribute whose value
 consists of a name containing a single null byte, represents
@@ -1682,12 +1849,18 @@ a program entity for which no name was given in the source.
 \textit{Because the names of program objects described by DWARF are the
 names as they appear in the source program, implementations
 of language translators that use some form of mangled name
+\addtoindex{mangled names}
 (as do many implementations of C++) should use the unmangled
-form of the name in the DWARF \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+form of the name in the 
+DWARF \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+\addtoindexx{name attribute}
 including the keyword operator (in names such as “operator
 +”), if present. See also 
 Section \refersec{chap:linkagenames} regarding the use
-of \livelink{chap:DWATlinkagename}{DW\-\_AT\-\_linkage\-\_name} for mangled names. Sequences of
+of \livelink{chap:DWATlinkagename}{DW\-\_AT\-\_linkage\-\_name} for 
+\addtoindex{mangled names}
+mangled names. 
+Sequences of
 multiple whitespace characters may be compressed.}
 
 \section{Data Locations and DWARF Procedures}
@@ -1695,17 +1868,31 @@ Any debugging information entry describing a data object (which
 \hypertarget{chap:DWATlocationdataobjectlocation}
 includes variables and parameters) or 
 common \livelink{chap:commonblockentry}{block}
-may have a
-\livelink{chap:DWATlocation}{DW\-\_AT\-\_location} attribute, whose value is a location description
-(see Section 2.6).  
-
-A DWARF procedure is represented by any
-kind of debugging information entry that has a \livelink{chap:DWATlocation}{DW\-\_AT\-\_location}
-attribute. If a suitable entry is not otherwise available,
+may have 
+\addtoindexx{location attribute}
+a
+\livelink{chap:DWATlocation}{DW\-\_AT\-\_location} attribute
+\addtoindexx{location attribute}
+, whose value is a location description
+(see Section \refersec{chap:locationdescriptions}).
+
+A 
+\addtoindex{DWARF procedure}
+is represented by any
+kind of debugging information entry that has 
+\addtoindexx{location attribute}
+a 
+\livelink{chap:DWATlocation}{DW\-\_AT\-\_location}
+attribute. 
+\addtoindexx{location attribute}
+If a suitable entry is not otherwise available,
 a DWARF procedure can be represented using a debugging
+\addtoindexx{DWARF procedure entry}
 information entry with the 
 tag \livetarg{chap:DWTAGdwarfprocedure}{DW\-\_TAG\-\_dwarf\-\_procedure}
-together with a \livelink{chap:DWATlocation}{DW\-\_AT\-\_location} attribute.  
+together with 
+\addtoindexx{location attribute}
+a \livelink{chap:DWATlocation}{DW\-\_AT\-\_location} attribute.  
 
 A DWARF procedure
 is called by a \livelink{chap:DWOPcall2}{DW\-\_OP\-\_call2}, 
@@ -1729,16 +1916,24 @@ and
 the like, may have
 
 \begin{itemize}
-\item A \livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc} and \livelink{chap:DWAThighpc}{DW\-\_AT\-\_high\-\_pc} pair of 
-attributes for a single contiguous range of
+\item A \livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc} and 
+\livelink{chap:DWAThighpc}{DW\-\_AT\-\_high\-\_pc} pair of 
+attributes 
+\addtoindexx{high PC attribute}
+for 
+\addtoindexx{low PC attribute}
+a single contiguous range of
 addresses, or
 
-\item A \livelink{chap:DWATranges}{DW\-\_AT\-\_ranges} attribute for a non-contiguous range of addresses.
+\item A \livelink{chap:DWATranges}{DW\-\_AT\-\_ranges} attribute 
+\addtoindexx{ranges attribute}
+for a non-contiguous range of addresses.
 \end{itemize}
 
 In addition, a non-contiguous range of 
 addresses may also be specified for the
 \livelink{chap:DWATstartscope}{DW\-\_AT\-\_start\-\_scope} attribute.
+\addtoindexx{start scope attribute}
 If an entity has no associated machine code, 
 none of these attributes are specified.
 
@@ -1749,15 +1944,24 @@ the entry has a \livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc} attribute whose
 relocated address for the entity.  While the \livelink{chap:DWATentrypc}{DW\-\_AT\-\_entry\-\_pc}
 attribute might also seem appropriate for this purpose,
 historically the \livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc} attribute was used before the
-\livelink{chap:DWATentrypc}{DW\-\_AT\-\_entry\-\_pc} was introduced (in DWARF Version 3). There is
+\livelink{chap:DWATentrypc}{DW\-\_AT\-\_entry\-\_pc} was introduced 
+(in \addtoindex{DWARF Version 3}). There is
 insufficient reason to change this.
 
 \subsection{Continuous Address Range}
 \label{chap:contiguousaddressranges}
 When the set of addresses of a debugging information entry can
-be described as a single continguous range, the entry may have
-a \livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc} and \livelink{chap:DWAThighpc}{DW\-\_AT\-\_high\-\_pc} pair of attributes. The value
-of the \livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc} attribute is the relocated address of the
+be described as a single continguous range, the entry 
+\addtoindexx{high PC attribute}
+may 
+\addtoindexx{low PC attribute}
+have
+a \livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc} and 
+\livelink{chap:DWAThighpc}{DW\-\_AT\-\_high\-\_pc} pair of attributes. 
+The value
+of the 
+\livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc} attribute 
+is the relocated address of the
 first instruction associated with the entity. If the value of
 the \livelink{chap:DWAThighpc}{DW\-\_AT\-\_high\-\_pc} is of class address, it is the relocated
 address of the first location past the last instruction
@@ -1775,41 +1979,63 @@ attributes should be produced.
 \subsection{Non\dash Contiguous Address Ranges}
 \label{chap:noncontiguousaddressranges}
 When the set of addresses of a debugging information entry
+\addtoindexx{non-contiguous address ranges}
 cannot be described as a single contiguous range, the entry has
-a \livelink{chap:DWATranges}{DW\-\_AT\-\_ranges} attribute whose value is of class \livelink{chap:rangelistptr}{rangelistptr}
-and indicates the beginning of a range list. Similarly,
-a \livelink{chap:DWATstartscope}{DW\-\_AT\-\_start\-\_scope} attribute may have a value of class
+a \livelink{chap:DWATranges}{DW\-\_AT\-\_ranges} attribute 
+\addtoindexx{ranges attribute}
+whose value is of class \livelink{chap:rangelistptr}{rangelistptr}
+and indicates the beginning of a \addtoindex{range list}.
+Similarly,
+a \livelink{chap:DWATstartscope}{DW\-\_AT\-\_start\-\_scope} attribute 
+\addtoindexx{start scope attribute}
+may have a value of class
 \livelink{chap:rangelistptr}{rangelistptr} for the same reason.  
 
 Range lists are contained
-in a separate object file section called .debug\_ranges. A
-range list is indicated by a \livelink{chap:DWATranges}{DW\-\_AT\-\_ranges} attribute whose
+in a separate object file section called 
+\addtoindex{.debug\_ranges}. A
+\addtoindex{range list} is indicated by a 
+\livelink{chap:DWATranges}{DW\-\_AT\-\_ranges} attribute whose
+\addtoindexx{ranges attribute}
 value is represented as an offset from the beginning of the
-.debug\_ranges section to the beginning of the range list.
+\addtoindex{.debug\_ranges} section to the beginning of the 
+\addtoindex{range list}.
 
-Each entry in a range list is either a range list entry,
-a base address selection entry, or an end of list entry.
+Each entry in a \addtoindex{range list} is either a 
+\addtoindex{range list} entry,
+\addtoindexx{base address selection entry!in range list}
+a base address selection entry, or an 
+\addtoindexx{end of list entry!in range list}
+end of list entry.
 
-A range list entry consists of:
+A \addtoindex{range list} entry consists of:
 
 \begin{enumerate}[1]
-\item A beginning address offset. This address offset has the size of an address and is relative to
-the applicable base address of the compilation unit referencing this range list. It marks the
+\item A beginning address offset. This address offset has the 
+\addtoindex{size of an address} and is relative to
+the applicable base address of the compilation unit referencing this 
+\addtoindex{range list}. 
+It marks the
 beginning of an 
 \addtoindexi{address}{address range!in range list} 
 range.
 
-\item An ending address offset. This address offset again has the size of an address and is relative
-to the applicable base address of the compilation unit referencing this range list. It marks the
-first address past the end of the address range.The ending address must be greater than or
+\item An ending address offset. This address offset again has the 
+\addtoindex{size of an address} and is relative
+to the applicable base address of the compilation unit referencing 
+this \addtoindex{range list}.
+It marks the
+first address past the end of the address range.
+The ending address must be greater than or
 equal to the beginning address.
 
-\textit{A range list entry (but not a base address selection or end of list entry) whose beginning and
+\textit{A \addtoindex{range list} entry (but not a base address selection or end of list entry) whose beginning and
 ending addresses are equal has no effect because the size of the range covered by such an
 entry is zero.}
 \end{enumerate}
 
-The applicable base address of a range list entry is determined
+The applicable base address of a \addtoindex{range list} entry
+is determined
 by the closest preceding base address selection entry (see
 below) in the same range list. If there is no such selection
 entry, then the applicable base address defaults to the base
@@ -1821,7 +2047,8 @@ code is contained in a single contiguous section, no base
 address selection entry is needed.}
 
 Address range entries in
-a range list may not overlap. There is no requirement that
+a \addtoindex{range list} may not overlap.
+There is no requirement that
 the entries be ordered in any particular way.
 
 A base address selection entry consists of:
@@ -1837,16 +2064,23 @@ and ending address offsets of subsequent entries of the location list.
 affects only the list in which it is contained.}
 
 
-The end of any given range list is marked by an end of
-list entry, which consists of a 0 for the beginning address
-offset and a 0 for the ending address offset. A range list
+The end of any given \addtoindex{range list} is marked by an 
+\addtoindexx{end of list entry!in range list}
+end of list entry, 
+which consists of a 0 for the beginning address
+offset and a 0 for the ending address offset. 
+A \addtoindex{range list}
 containing only an end of list entry describes an empty scope
 (which contains no instructions).
 
-\textit{A base address selection entry and an end of list entry for
-a range list are identical to a base address selection entry
+\textit{A base address selection entry and an 
+\addtoindexx{end of list entry!in range list}
+end of list entry for
+a \addtoindex{range list} 
+are identical to a base address selection entry
 and end of list entry, respectively, for a location list
-(see Section 2.6.2) in interpretation and representation.}
+(see Section \refersec{chap:locationlists}) 
+in interpretation and representation.}
 
 
 
@@ -1894,7 +2128,7 @@ evaluation of the expression yields the value of
 the attribute.
 \end{itemize}
 
-\textit{
+\textit{%
 Whether an attribute value can be dynamic depends on the
 rules of the applicable programming language.
 }
@@ -1919,16 +2153,21 @@ in the program that are artificial, or which otherwise are
 ``named'' in ways which are not valid identifiers in the
 programming language. For example, several languages may
 capture or freeze the value of a variable at a particular
-point in the program. Ada 95 has package elaboration routines,
+point in the program. 
+\addtoindex{Ada} 95 has package elaboration routines,
 type descriptions of the form typename’Class, and 
 ``access typename'' parameters.  }
 
 Generally, any debugging information
 entry that 
 \hypertarget{chap:DWATdescriptionartificialnameordescription}
-has, or may have, a 
+has, or may have, 
+\addtoindexx{name attribute}
+a 
 \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, may
-also have a 
+also have 
+\addtoindexx{description attribute}
+a 
 \livelink{chap:DWATdescription}{DW\-\_AT\-\_description} attribute whose value is a
 null-terminated string providing a description of the entity.
 
@@ -1944,7 +2183,7 @@ assigned, or the like.}
 Many debugging information entries allow either a
 \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} attribute or a \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size} attribute,
 whose integer constant value 
-(see \refersec{chap:staticanddynamicvaluesofattributes}) 
+(see Section \refersec{chap:staticanddynamicvaluesofattributes}) 
 specifies an
 amount of storage. The value of the \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} attribute
 is interpreted in bytes and the value of the \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size}
@@ -1957,11 +2196,17 @@ attribute is interpreted in bits.
 
 \section{Linkage Names}
 \label{chap:linkagenames}
-\textit{Some language implementations, notably C++ and similar
-languages, make use of implementation defined names within
+\textit{Some language implementations, notably 
+\addtoindex{C++} and similar
+languages, 
+make use of implementation defined names within
 object files that are different from the identifier names
-(see \refersec{chap:identifiernames}) of entities as they appear in the
-source. Such names, sometimes known as mangled names,
+(see Section \refersec{chap:identifiernames}) of entities as they appear in the
+source. Such names, sometimes known 
+\addtoindex{names!mangled}
+as 
+\addtoindexx{mangled names}
+mangled names,
 are used in various ways, such as: to encode additional
 information about an entity, to distinguish multiple entities
 that have the same name, and so on. When an entity has an
@@ -1975,7 +2220,9 @@ that is encoded in the linkage name itself.
 
 % Some trouble maybe with hbox full, so we try optional word breaks.
 A debugging
-information entry may have a 
+information entry may have 
+\addtoindexx{linkage name attribute}
+a 
 \livelink{chap:DWATlinkagename}{DW\-\_AT\-\_linkage\-\_name}
 attribute
 whose value is a null-terminated string describing the object