This indexes letters f, g, and h.
[dwarf-doc.git] / dwarf5 / latexdoc / generaldescription.tex
index 6eaac51..553e93c 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,222 +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} 
-&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} 
-&Binary scale factor for fixed\dash 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} 
-&Base type bit location \\
-&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} 
-&Base type bit size \\
-&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} 
-&Array element stride (of array type) \\
-&Subrange stride (dimension of array type) \\
-&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} 
-&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} 
-&Array element stride (of array type) \\
-&Subrange stride (dimension of array type) \\
-&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} 
-&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}
-&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} 
-&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} 
-&Subprogram calling convention \\
-&\livetarg{chap:DWATcommonreference}{DW\-\_AT\-\_common\-\_reference} \\
-&Common \livelink{chap:commonblockreferenceattribute} usage \\
+&\livelinki{chap:DWATcallingconventionsubprogramcallingconvention}{Subprogram calling convention}{subprogram calling convention} \\
+\livetarg{chap:DWATcommonreference}{DW\-\_AT\-\_common\-\_reference}
+&\livelinki{chap:commonreferencecommonblockusage}{Common block usage}{common block usage} \\
 \livetarg{chap:DWATcompdir}{DW\-\_AT\-\_comp\-\_dir}
-&Compilation directory \\
+&\livelinki{chap:DWATcompdircompilationdirectory}{Compilation directory}{compilation directory} \\
 \livetarg{chap:DWATconstvalue}{DW\-\_AT\-\_const\-\_value}
-&Constant object \\
-\livelink{chap:DWATconstvalue}{DW\-\_AT\-\_const\-\_value}
-&Enumeration literal value \\
-&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}
-&Compile\dash time constant object \\
-&Compile\dash 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}
-&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}
-&Elements of subrange type \\
+&\livelinki{chap:DWATcountelementsofsubrangetype}{Elements of subrange type}{elements of subrange type} \\
 \livetarg{chap:DWATdatabitoffset}{DW\-\_AT\-\_data\-\_bit\-\_offset}
-&Base type bit location \\
-&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} 
-&Indirection to actual data \\
+&\livelinki{chap:DWATdatalocationindirectiontoactualdata}{Indirection to actual data}{indirection to actual data} \\
 \livetarg{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location}
-&Data member location \\
-&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}
-&Decimal scale factor \\
+&\livelinki{chap:DWATdecimalscaledecimalscalefactor}{Decimal scale factor}{decimal scale factor} \\
 \livetarg{chap:DWATdecimalsign}{DW\-\_AT\-\_decimal\-\_sign}
-&Decimal sign representation \\
+&\livelinki{chap:DWATdecimalsigndecimalsignrepresentation}{Decimal sign representation}{decimal sign representation} \\
 \livetarg{chap:DWATdeclcolumn}{DW\-\_AT\-\_decl\-\_column}
-&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}
-&File containing source declaration \\
+&\livelinki{chap:DWATdeclfilefilecontainingsourcedeclaration}{File containing source declaration}{file containing source declaration} \\
 \livetarg{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line}
-&Line number of source declaration \\
+&\livelinki{chap:DWATdecllinelinenumberofsourcedeclaration}{Line number of source declaration}{line number of source declaration} \\
 \livetarg{chap:DWATdeclaration}{DW\-\_AT\-\_declaration}
-&Incomplete, non\dash 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}
-&Default value of parameter \\
+&\livelinki{chap:DWATdefaultvaluedefaultvalueofparameter}{Default value of parameter}{default value of parameter} \\
 \livetarg{chap:DWATdescription}{DW\-\_AT\-\_description} 
-& Artificial name or description \\
+&\livelinki{chap:DWATdescriptionartificialnameordescription}{Artificial name or description}{artificial name or description} \\
 \livetarg{chap:DWATdigitcount}{DW\-\_AT\-\_digit\-\_count}
-&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}
-&Discriminant of variant part\\
+&\livelinki{chap:DWATdiscrdiscriminantofvariantpart}{Discriminant of variant part}{discriminant of variant part} \\
 \livetarg{chap:DWATdiscrlist}{DW\-\_AT\-\_discr\-\_list}
-&List of discriminant values\\
+&\livelinki{chap:DWATdiscrlistlistofdiscriminantvalues}{List of discriminant values}{list of discriminant values} \\
 \livetarg{chap:DWATdiscrvalue}{DW\-\_AT\-\_discr\-\_value}
-&Discriminant value\\
+&\livelinki{chap:DWATdiscrvaluediscriminantvalue}{Discriminant value}{discriminant value} \\
 \livetarg{chap:DWATelemental}{DW\-\_AT\-\_elemental}
-&Elemental property of a subroutine\\
+&\livelinki{chap:DWATelementalelementalpropertyofasubroutine}{Elemental property of a subroutine}{elemental property of a subroutine} \\
 \livetarg{chap:DWATencoding}{DW\-\_AT\-\_encoding}
-&Encoding of base type\\
+&\livelinki{chap:DWATencodingencodingofbasetype}{Encoding of base type}{encoding of base type} \\
 \livetarg{chap:DWATendianity}{DW\-\_AT\-\_endianity}
-&Endianity of data\\
+&\livelinki{chap:DWATendianityendianityofdata}{Endianity of data}{endianity of data} \\
 \livetarg{chap:DWATentrypc}{DW\-\_AT\-\_entry\-\_pc}
-&Entry address of module initialization\\
-&Entry address of subprogram\\
-&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}
-&Type safe enumeration definition\\
+&\livelinki{chap:DWATenumclasstypesafeenumerationdefinition}{Type safe enumeration definition}{type safe enumeration definition}\\
 \livetarg{chap:DWATexplicit}{DW\-\_AT\-\_explicit}
-&Explicit property of member function\\
+&\livelinki{chap:DWATexplicitexplicitpropertyofmemberfunction}{Explicit property of member function}{explicit property of member function}\\
 \livetarg{chap:DWATextension}{DW\-\_AT\-\_extension}
-&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}
-&External subroutine\\
-&External variable\\
+&\livelinki{chap:DWATexternalexternalsubroutine}{External subroutine}{external subroutine} \\
+&\livelinki{chap:DWATexternalexternalvariable}{External variable}{external variable} \\
 \livetarg{chap:DWATframebase}{DW\-\_AT\-\_frame\-\_base}
-&Subroutine frame base address\\
+&\livelinki{chap:DWATframebasesubroutineframebaseaddress}{Subroutine frame base address}{subroutine frame base address} \\
 \livetarg{chap:DWATfriend}{DW\-\_AT\-\_friend}
-&Friend relationship\\
+&\livelinki{chap:DWATfriendfriendrelationship}{Friend relationship}{friend relationship} \\
 \livetarg{chap:DWAThighpc}{DW\-\_AT\-\_high\-\_pc}
-&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}
-&Identifier case rule \\
+&\livelinki{chap:DWATidentifiercaseidentifiercaserule}{Identifier case rule}{identifier case rule} {identifier case rule}{identifier case rule}\\
 \livetarg{chap:DWATimport}{DW\-\_AT\-\_import}
-&Imported declaration \\
-&Imported unit \\
-&Namespace alias \\
-&Namespace using declaration \\
-&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}
-&Abstract instance\\
-&Inlined subroutine\\
+&\livelinki{chap:DWATinlineabstracttinstance}{Abstract instance}{abstract instance} \\
+&\livelinki{chap:DWATinlineinlinedsubroutine}{Inlined subroutine}{inlined subroutine} \\
 \livetarg{chap:DWATisoptional}{DW\-\_AT\-\_is\-\_optional}
-&Optional parameter\\
+&\livelinki{chap:DWATisoptionaloptionalparameter}{Optional parameter}{optional parameter} \\
 \livetarg{chap:DWATlanguage}{DW\-\_AT\-\_language}
-&Programming language\\
+&\livelinki{chap:DWATlanguageprogramminglanguage}{Programming language}{programming language} \\
 \livetarg{chap:DWATlinkagename}{DW\-\_AT\-\_linkage\-\_name}
-&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}
-&Data object location\\
+&\livelinki{chap:DWATlocationdataobjectlocation}{Data object location}{data object location}\\
 \livetarg{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc}
-&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}
-&Lower bound of subrange\\
+&\livelinki{chap:DWATlowerboundlowerboundofsubrange}{Lower bound of subrange}{lower bound of subrange} \\
 \livetarg{chap:DWATmacroinfo}{DW\-\_AT\-\_macro\-\_info}
-&Macro information (\#define, \#undef)\\
+&\livelinki{chap:DWATmacroinfomacroinformation}{Macro information} {macro information} (\#define, \#undef)\\
 \livetarg{chap:DWATmainsubprogram}{DW\-\_AT\-\_main\-\_subprogram}
-&Main or starting subprogram\\
-&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}
-&Mutable property of member data\\
+&\livelinki{chap:DWATmutablemutablepropertyofmemberdata}{Mutable property of member data}{mutable property of member data} \\
 \livetarg{chap:DWATname}{DW\-\_AT\-\_name}
-&Name of declaration\\
-&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}
-&Namelist item\\
+&\livelinki{chap:DWATnamelistitemnamelistitem}{Namelist item}{namelist item}\\
 \livetarg{chap:DWATobjectpointer}{DW\-\_AT\-\_object\-\_pointer}
-&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}
-&Array row/column ordering\\
+&\livelinki{chap:DWATorderingarrayrowcolumnordering}{Array row/column ordering} {array row/column ordering}\\
 \livetarg{chap:DWATpicturestring}{DW\-\_AT\-\_picture\-\_string}
-&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}
-&Module priority\\
+&\livelinki{chap:DWATprioritymodulepriority}{Module priority}{module priority}\\
 \livetarg{chap:DWATproducer}{DW\-\_AT\-\_producer}
-&Compiler identification\\
+&\livelinki{chap:DWATproducercompileridentification}{Compiler identification}{compiler identification}\\
 \livetarg{chap:DWATprototyped}{DW\-\_AT\-\_prototyped}
-&Subroutine prototype\\
+&\livelinki{chap:DWATprototypedsubroutineprototype}{Subroutine prototype}{subroutine prototype}\\
 \livetarg{chap:DWATpure}{DW\-\_AT\-\_pure}
-&Pure property of a subroutine\\
+&\livelinki{chap:DWATpurepurepropertyofasubroutine}{Pure property of a subroutine}{pure property of a subroutine} \\
 \livetarg{chap:DWATranges}{DW\-\_AT\-\_ranges}
-&Non\dash 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}
-&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}
-&Subroutine return address save location\\
+&\livelinki{chap:DWATreturnaddrsubroutinereturnaddresssavelocation}{Subroutine return address save location}{subroutine return address save location} \\
 \livetarg{chap:DWATsegment}{DW\-\_AT\-\_segment}
-&Addressing information\\
+&\livelinki{chap:DWATsegmentaddressinginformation}{Addressing information}{addressing information} \\
 \livetarg{chap:DWATsibling}{DW\-\_AT\-\_sibling}
-&Debugging information entry relationship\\
+&\livelinki{chap:DWATsiblingdebugginginformationentryrelationship}{Debugging information entry relationship}{debugging information entry relationship} \\
 \livetarg{chap:DWATsmall}{DW\-\_AT\-\_small}
-&Scale factor for fixed\dash point type\\
+&\livelinki{chap:DWATsmallscalefactorforfixedpointtype}{Scale factor for fixed-point type}{scale factor for fixed-point type} \\
 \livetarg{chap:DWATsignature}{DW\-\_AT\-\_signature}
-&Type signature\\
+&\livelinki{chap:DWATsignaturetypesignature}{Type signature}{type signature}\\
 \livetarg{chap:DWATspecification}{DW\-\_AT\-\_specification}
-&Incomplete, non\dash 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}
-&Object declaration\\
-&Type declaration\\
+&\livelinki{chap:DWATstartscopeobjectdeclaration}{Object declaration}{object declaration}\\
+&\livelinki{chap:DWATstartscopetypedeclaration}{Type declaration}{type declaration}\\
 \livetarg{chap:DWATstaticlink}{DW\-\_AT\-\_static\-\_link}
-&Location of uplevel frame\\
+&\livelinki{chap:DWATstaticlinklocationofuplevelframe}{Location of uplevel frame}{location of uplevel frame} \\
 \livetarg{chap:DWATstmtlist}{DW\-\_AT\-\_stmt\-\_list}
-&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}
-&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}
-&UPC array bound THREADS scale factor\\
+&\livelink{chap:DWATthreadsscaledupcarrayboundthreadsscalfactor}{UPC array bound THREADS scale factor}\\
 \livetarg{chap:DWATtrampoline}{DW\-\_AT\-\_trampoline}
-&Target subroutine\\
+&\livelinki{chap:DWATtrampolinetargetsubroutine}{Target subroutine}{target subroutine of trampoline} \\
 \livetarg{chap:DWATtype}{DW\-\_AT\-\_type}
-&Type of declaration\\
-&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}
-&Upper bound of subrange\\
+&\livelinki{chap:DWATupperboundupperboundofsubrange}{Upper bound of subrange}{upper bound of subrange} \\
 \livetarg{chap:DWATuselocation}{DW\-\_AT\-\_use\-\_location}
-&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}
-&Compilation unit uses UTF\dash 8 strings \\
+&\livelinki{chap:DWATuseUTF8compilationunitusesutf8strings}{Compilation unit uses UTF-8 strings}{compilation unit uses UTF-8 strings} \\
 \livetarg{chap:DWATvariableparameter}{DW\-\_AT\-\_variable\-\_parameter}
-&Non\dash constant parameter \livelink{chap:flag}{flag} \\
+&\livelink{chap:DWATvariableparameternonconstantparameterflag}{Non-constant parameter flag}{non-constant parameter flag}  \\
 \livetarg{chap:DWATvirtuality}{DW\-\_AT\-\_virtuality}
-&Virtuality indication \\
-&Virtuality of base class \\
-&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}
-&Visibility of declaration\\
+&\livelinki{chap:DWATvisibilityvisibilityofdeclaration}{Visibility of declaration}{visibility of declaration} \\
 \livetarg{chap:DWATvtableelemlocation}{DW\-\_AT\-\_vtable\-\_elem\-\_location}
-&Virtual function vtable slot\\
+&\livelinki{chap:DWATvtableelemlocationvirtualfunctiontablevtableslot}{Virtual function vtable slot}{virtual function vtable slot}\\
 \end{longtable}
 
 \begin{figure}[here]
@@ -376,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
@@ -428,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
@@ -443,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
@@ -452,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,
@@ -467,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. 
@@ -478,6 +491,7 @@ children are represented as siblings of the first child.
 A chain of sibling entries is terminated by a null entry.
 
 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
@@ -489,7 +503,12 @@ of the entry to which the attribute is attached.
 
 \section{Target Addresses}
 \label{chap:targetaddresses}
-Many places in this document refer to the size of an address
+Many places in this document 
+refer
+\addtoindexx{address size|see{size of an address}}
+to the size 
+of an
+\addtoindexi{address}{size of an address}
 on the target architecture (or equivalently, target machine)
 to which a DWARF description applies. For processors which
 can be configured to have different address sizes or different
@@ -498,9 +517,7 @@ 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
@@ -509,13 +526,12 @@ 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
@@ -531,22 +547,29 @@ 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
+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.
@@ -583,6 +606,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.
 
@@ -613,7 +637,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.
 
@@ -648,10 +674,14 @@ stack entry, the second entry becomes the top of the stack,
 and the third entry becomes the second entry.
 
 \item  \livetarg{chap:DWOPderef}{DW\-\_OP\-\_deref} \\
-The \livelink{chap:DWOPderef}{DW\-\_OP\-\_deref} operation pops the top stack entry and 
+The 
+\livelink{chap:DWOPderef}{DW\-\_OP\-\_deref} 
+operation 
+pops the top stack entry and 
 treats it as an address. The value
 retrieved from that address is pushed. 
-The size of the data retrieved from the dereferenced
+The size of the data retrieved from the 
+\addtoindexi{dereferenced}{address!dereference operator}
 address is the size of an address on the target machine.
 
 \item \livetarg{chap:DWOPderefsize}{DW\-\_OP\-\_deref\-\_size} \\
@@ -669,24 +699,30 @@ target machine before being pushed onto the expression stack.
 \item \livetarg{chap:DWOPxderef}{DW\-\_OP\-\_xderef} \\
 The \livelink{chap:DWOPxderef}{DW\-\_OP\-\_xderef} operation provides an extended dereference
 mechanism. The entry at the top of the stack is treated as an
-address. The second stack entry is treated as an “address
-space identifier” for those architectures that support
-multiple address spaces. The top two stack elements are popped,
+address. The second stack entry is treated as an ``address
+space identifier'' for those architectures that support
+\addtoindexi{multiple}{address space!multiple}
+address spaces. The top two stack elements are popped,
 and a data item is retrieved through an implementation\dash defined
 address calculation and pushed as the new stack top. The size
-of the data retrieved from the dereferenced address is the
+of the data retrieved from the 
+\addtoindexi{dereferenced}{address!dereference operator}
+address is the
 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
 \livelink{chap:DWOPxderef}{DW\-\_OP\-\_xderef} operation.The entry at the top of the stack is
 treated as an address. The second stack entry is treated as
-an “address space identifier” for those architectures
-that support multiple address spaces. The top two stack
+an ``address space identifier'' for those architectures
+that support 
+\addtoindexi{multiple}{address space!multiple}
+address spaces. The top two stack
 elements are popped, and a data item is retrieved through an
 implementation\dash defined address calculation and pushed as the
 new stack top. In the \livelink{chap:DWOPxderefsize}{DW\-\_OP\-\_xderef\-\_size} operation, however,
-the size in bytes of the data retrieved from the dereferenced
+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
@@ -703,7 +739,9 @@ structure, or class whose address has been dynamically
 determined by an earlier step during user expression
 evaluation.  This operator provides explicit functionality
 (especially for arrays involving descriptors) that is analogous
-to the implicit push of the base address of a structure prior
+to the implicit push of the base 
+\addtoindexi{address}{address!implicit push of base}
+of a structure prior
 to evaluation of a \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} to access a
 data member of a structure. For an example, see 
 Appendix \refersec{app:aggregateexamples}.
@@ -718,7 +756,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
@@ -747,7 +786,11 @@ 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
@@ -802,7 +845,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,
@@ -832,7 +875,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:
@@ -885,7 +930,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
@@ -914,7 +962,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
@@ -922,7 +972,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.
@@ -965,7 +1017,7 @@ examples illustrate their behavior graphically.
 
 \section{Location Descriptions}
 \label{chap:locationdescriptions}
-\textit{ Debugging information must provide consumers a way to find
+\textit{Debugging information must 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
@@ -980,7 +1032,7 @@ of two forms:
 \begin{enumerate}[1]
 \item \textit{Single location descriptions}, which are 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
@@ -1011,7 +1063,9 @@ 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).
@@ -1129,7 +1183,8 @@ 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
 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).
@@ -1276,13 +1331,19 @@ Location lists are used in place of location expressions
 whenever the object whose location is being described
 can change location during its lifetime. Location lists
 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 list entry,
-a base address selection entry, or an end of list entry.
+Each entry in a location list is either a location 
+\addtoindexi{list}{address selection|see{base address selection}} 
+entry,
+a 
+\addtoindexi{base}{base address selection entry!in location list} 
+address selection entry, or an 
+\addtoindexx{end of list entry!in location list}
+end of list entry.
 
 A location list entry consists of:
 
@@ -1291,7 +1352,9 @@ A location list entry consists of:
 This address offset has the 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 range over which the location is valid.
+of the address 
+\addtoindexi{range}{address range!in location list} 
+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
@@ -1300,8 +1363,10 @@ 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 
@@ -1326,7 +1391,10 @@ list do not collectively cover the entire range over which the
 object in question is defined, it is assumed that the object is
 not available for the portion of the range that is not covered.
 
-A base address selection entry consists of:
+A base 
+\addtoindexi{address}{address selection|see{base address selection}}
+selection 
+\addtoindexi{entry}{base address selection entry!in location list}:
 \begin{enumerate}[1]
 \item The value of the largest representable 
 address offset (for example, 0xffffffff when the size of
@@ -1343,7 +1411,9 @@ 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
 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
@@ -1364,7 +1434,9 @@ and representation.}
 
 \section{Types of Program Entities}
 \label{chap:typesofprogramentities}
-Any debugging information entry describing a declaration that
+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
 reference to another debugging information entry. The entry
 referenced may describe a base type, that is, a type that is
@@ -1383,7 +1455,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.}
@@ -1391,7 +1464,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}.
 
@@ -1415,8 +1490,11 @@ visibility specifies which declarations are to be
 visible outside of the entity in which they are
 declared.}
 
-The visibility of a declaration is represented 
-by a \livelink{chap:DWATvisibility}{DW\-\_AT\-\_visibility} attribute, whose value is a
+The 
+\hypertarget{chap:DWATvisibilityvisibilityofdeclaration}
+visibility of a declaration is represented 
+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}.
 
@@ -1436,8 +1514,11 @@ Figure \ref{fig:visibilitycodes}.
 \textit{C++ provides for virtual and pure virtual structure or class
 member functions and for virtual base classes.}
 
-The virtuality of a declaration is represented by a
-\livelink{chap:DWATvirtuality}{DW\-\_AT\-\_virtuality} attribute, whose value is a constant drawn
+The 
+\hypertarget{chap:DWATvirtualityvirtualityindication}
+virtuality of a declaration is represented by a
+\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}.
 
@@ -1462,6 +1543,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}
@@ -1472,16 +1554,28 @@ which is a \livelink{chap:flag}{flag}.
 \section{Segmented Addresses}
 \label{chap:segmentedaddresses}
 \textit{In some systems, addresses are specified as offsets within a
-given segment rather than as locations within a single flat
+given 
+\addtoindexx{address space!segmented}
+segment rather than as locations within a single flat
+\addtoindexx{address space!flat}.
 address space.}
 
 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
+a 
+\livelink{chap:DWATsegment}{DW\-\_AT\-\_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}.
@@ -1493,16 +1587,23 @@ its containing compilation unit entry have \livelink{chap:DWATsegment}{DW\-\_AT\
 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
-entry is assumed to exist within a flat address space.
+entry is assumed to exist within a 
+\addtoindexi{flat}{address space!flat}.
+address space.
 
-\textit{Some systems support different classes of addresses. The
+\textit{Some systems support different classes of 
+addresses
+\addtoindexx{address class!attribute}. 
+The
 address class may affect the way a pointer is dereferenced
 or the way a subroutine is called.}
 
 
 Any debugging information entry representing a pointer or
-reference type or a subroutine or subroutine type may have
-a \livelink{chap:DWATaddressclass}{DW\-\_AT\-\_address\-\_class} attribute, whose value is an integer
+reference type or a subroutine or subroutine type may 
+have a 
+\livelink{chap:DWATaddressclass}{DW\-\_AT\-\_address\-\_class}
+attribute, whose value is an integer
 constant.  The set of permissible values is specific to
 each target architecture. The value \livetarg{chap:DWADDRnone}{DW\-\_ADDR\-\_none}, 
 however,
@@ -1534,9 +1635,10 @@ 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
 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()
@@ -1550,43 +1652,110 @@ 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 
+\addtoindexx{declaration attribute}
+a 
+\livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration} 
+attribute, which is a 
+\livelink{chap:flag}{flag}.
+
+\subsection{Declarations Completing Non-Defining Declarations}
+A debugging information entry that represents a 
+\hypertarget{chap:DWATspecificationincompletenondefiningorseparatedeclaration}
+declaration that completes another (earlier) 
+non\dash defining declaration may have a 
+\livelink{chap:DWATspecification}{DW\-\_AT\-\_specification}
+attribute whose value is a reference to
+the debugging information entry representing the non-defining declaration. A debugging
+information entry with a 
+\livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} 
+attribute does not need to duplicate information
+provided by the debugging information entry referenced by that specification attribute.
+
+It is not the case that all attributes of the debugging information entry referenced by a
+\livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} attribute 
+apply to the referring debugging information entry.
+
+\textit{For 
+\addtoindexx{declaration attribute}
+example,
+\livelink{chap:DWATsibling}{DW\-\_AT\-\_sibling} and 
+\livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration} 
+\addtoindexx{declaration attribute}
+clearly cannot apply to a referring
+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.
 }
 
-Any debugging information entry representing 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}
+Any debugging information 
+\hypertarget{chap:DWATdeclfilefilecontainingsourcedeclaration}
+entry 
+\hypertarget{chap:DWATdecllinelinenumberofsourcedeclaration}
+representing 
+\hypertarget{chap:DWATdeclcolumncolumnpositionofsourcedeclaration}
+the
+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.
 
 \section{Identifier Names}
 \label{chap:identifiernames}
-Any debugging information entry representing a program entity
-that has been given a name may have a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+Any 
+\hypertarget{chap:DWATnamenameofdeclaration}
+debugging information entry representing 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
 the source program. A debugging information entry containing
 no name attribute, or containing a name attribute whose value
@@ -1606,14 +1775,22 @@ multiple whitespace characters may be compressed.}
 
 \section{Data Locations and DWARF Procedures}
 Any debugging information entry describing a data object (which
-includes variables and parameters) or common \livelink{chap:commonblockentry}{block} may have a
+\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).  
+(see Section \refersec{chap:locationdescriptions}).
 
-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,
+A 
+\addtoindex{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,
 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.  
@@ -1630,17 +1807,28 @@ DWARF expression operator
 Any debugging information entry describing an entity that has
 a machine code address or range of machine code addresses,
 which includes compilation units, module initialization,
+\hypertarget{chap:DWATrangesnoncontiguousrangeofcodeaddresses}
 subroutines, ordinary \livelink{chap:lexicalblock}{block}, 
 try/catch \nolink{blocks} (see Section\refersec{chap:tryandcatchblockentries}), 
-labels and
+labels 
+\hypertarget{chap:DWATlowpccodeaddressorrangeofaddresses}
+and
+\hypertarget{chap:DWAThighpccontinguousrangeofcodeaddresses}
 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 
@@ -1656,15 +1844,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
@@ -1683,30 +1880,41 @@ attributes should be produced.
 \label{chap:noncontiguousaddressranges}
 When the set of addresses of a debugging information entry
 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}
+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 range list. Similarly,
 a \livelink{chap:DWATstartscope}{DW\-\_AT\-\_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
+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 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.
+\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:
 
 \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
-beginning of an address range.
+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
+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
@@ -1742,16 +1950,21 @@ 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
+The end of any given 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 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
+\textit{A base address selection entry and an 
+\addtoindexx{end of list entry!in range list}
+end of list entry for
 a 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.}
 
 
 
@@ -1799,7 +2012,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.
 }
@@ -1824,13 +2037,20 @@ 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 has, or may have, a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, may
-also have a \livelink{chap:DWATdescription}{DW\-\_AT\-\_description} attribute whose value is a
+entry that 
+\hypertarget{chap:DWATdescriptionartificialnameordescription}
+has, or may have, a 
+\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, may
+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.
 
 
@@ -1845,7 +2065,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}
@@ -1858,10 +2078,11 @@ attribute is interpreted in bits.
 
 \section{Linkage Names}
 \label{chap:linkagenames}
-\textit{Some language implementations, notably C++ and similar
+\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
+(see Section \refersec{chap:identifiernames}) of entities as they appear in the
 source. Such names, sometimes known as mangled names,
 are used in various ways, such as: to encode additional
 information about an entity, to distinguish multiple entities
@@ -1870,12 +2091,15 @@ associated distinct linkage name it may sometimes be useful
 for a producer to include this name in the DWARF description
 of the program to facilitate consumer access to and use of
 object file information about an entity and/or information
+\hypertarget{chap:DWATlinkagenameobjectfilelinkagenameofanentity}
 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 \livelink{chap:DWATlinkagename}{DW\-\_AT\-\_linkage\-\_name} attribute
+information entry may have a 
+\livelink{chap:DWATlinkagename}{DW\-\_AT\-\_linkage\-\_name}
+attribute
 whose value is a null-terminated string describing the object
 file linkage name associated with the corresponding entity.