compression.tex
[dwarf-doc.git] / dwarf5 / latexdoc / programscope.tex
index 0f321be..b493c89 100644 (file)
@@ -65,12 +65,18 @@ partial compilation unit (see
 Section \refersec{chap:importedunitentries}).
 
 
-Compilation unit entries may have the following attributes:
+Compilation unit entries may have the following 
+attributes:
 
 \begin{enumerate}[1]
 \item Either a \livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc} and \livelink{chap:DWAThighpc}{DW\-\_AT\-\_high\-\_pc} pair of
-attributes or a \livelink{chap:DWATranges}{DW\-\_AT\-\_ranges} attribute whose values encode the
-contiguous or non\dash contiguous address ranges, respectively,
+attributes or a 
+\livelink{chap:DWATranges}{DW\-\_AT\-\_ranges} attribute
+whose values encode 
+\addtoindexx{discontiguous address ranges|see{non-contiguous address ranges}}
+the
+contiguous or 
+non\dash contiguous address ranges, respectively,
 of the machine instructions generated for the compilation
 unit (see Section {chap:codeaddressesandranges}).  
 A \livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc} attribute may also
@@ -86,6 +92,7 @@ containing the full or relative path name of the primary
 source file from which the compilation unit was derived.
 
 \item A \livelink{chap:DWATlanguage}{DW\-\_AT\-\_language} attribute whose constant value is an
+\hypertarget{chap:DWATlanguageprogramminglanguage}
 integer code indicating the source language of the compilation
 unit. The set of language names and their meanings are given
 in 
@@ -97,8 +104,8 @@ Figure \refersec{fig:languagenames}.
 \label{fig:languagenames}
 \begin{tabular}{ll}
 Language name & Meaning\\ \hline
-\livetarg{chap:DWLANGAda83}{DW\-\_LANG\-\_Ada83} \dag&ISO Ada:1983 \\
-\livetarg{chap:DWLANGAda95}{DW\-\_LANG\-\_Ada95} \dag&ISO Ada:1995 \\
+\livetarg{chap:DWLANGAda83}{DW\-\_LANG\-\_Ada83} \dag&ISO Ada:1983 \addtoindexx{Ada} \\
+\livetarg{chap:DWLANGAda95}{DW\-\_LANG\-\_Ada95} \dag&ISO Ada:1995 \addtoindexx{Ada} \\
 \livetarg{chap:DWLANGC}{DW\-\_LANG\-\_C}&Non-standardized C, such as K\&R \\
 \livetarg{chap:DWLANGC89}{DW\-\_LANG\-\_C89}&ISO C:1989 \\
 \livetarg{chap:DWLANGC99}{DW\-\_LANG\-\_C99} & ISO C:1999 \\
@@ -122,11 +129,12 @@ Language name & Meaning\\ \hline
 \end{figure}
 
 \item A \livelink{chap:DWATstmtlist}{DW\-\_AT\-\_stmt\-\_list} attribute whose value is a section
+\hypertarget{chap:DWATstmtlistlinenumberinformationforunit}
 offset to the line number information for this compilation
 unit.  This information is placed in a separate object file
 section from the debugging information entries themselves. The
 value of the statement list attribute is the offset in the
-.debug\_line section of the first byte of the line number
+\addtoindex{.debug\_line} section of the first byte of the line number
 information for this compilation unit 
 (see Section \refersec{chap:linenumberinformation}).
 
@@ -136,7 +144,7 @@ offset to the macro information for this compilation unit.
 This information is placed in a separate object file section
 from the debugging information entries themselves. The
 value of the macro information attribute is the offset in
-the .debug\_macinfo section of the first byte of the macro
+the \addtoindex{.debug\_macinfo} section of the first byte of the macro
 information for this compilation unit 
 (see Section \refersec{chap:macroinformation}).
 
@@ -151,6 +159,7 @@ unit in whatever form makes sense for the host system.
 
 \item  A \livelink{chap:DWATproducer}{DW\-\_AT\-\_producer} attribute whose value is a null\dash
 terminated string containing information about the compiler
+\hypertarget{chap:DWATproducercompileridentification}
 that produced the compilation unit. The actual contents of
 the string will be specific to each producer, but should
 begin with the name of the compiler vendor or some other
@@ -158,7 +167,9 @@ identifying character sequence that should avoid confusion
 with other producer values.
 
 
-\item  A \livelink{chap:DWATidentifiercase}{DW\-\_AT\-\_identifier\-\_case} attribute whose integer
+\item  A \livelink{chap:DWATidentifiercase}{DW\-\_AT\-\_identifier\-\_case} 
+attribute whose integer
+\hypertarget{chap:DWATidentifiercaseidentifiercaserule}
 constant value is a code describing the treatment
 of identifiers within this compilation unit. The
 set of identifier case codes is given in Figure
@@ -205,7 +216,9 @@ access those names.
 
 This 
 \hypertarget{chap:DWATbasetypesprimitivedatatypesofcompilationunit}
-attribute points to a debugging information entry
+attribute 
+\addtoindexx{base types attribute}
+points to a debugging information entry
 representing another compilation unit.  It may be used
 to specify the compilation unit containing the base type
 entries used by entries in the current compilation unit
@@ -214,7 +227,10 @@ entries used by entries in the current compilation unit
 This attribute provides a consumer a way to find the definition
 of base types for a compilation unit that does not itself
 contain such definitions. This allows a consumer, for example,
-to interpret a type conversion to a base type correctly.
+to interpret a type conversion to a base type 
+% getting this link target at the right spot is tricky.
+\hypertarget{chap:DWATuseUTF8compilationunitusesutf8strings}
+correctly.
 
 \item A \livelink{chap:DWATuseUTF8}{DW\-\_AT\-\_use\-\_UTF8} attribute, 
 which is a \livelink{chap:flag}{flag} whose
@@ -232,9 +248,10 @@ subprogram that has been identified as the starting function
 of the program. If more than one compilation unit contains
 this \nolink{flag}, any one of them may contain the starting function.
 
-\textit{Fortran has a PROGRAM statement which is used
+\textit{\addtoindex{Fortran} has a PROGRAM statement which is used
 to specify and provide a user\dash specified name for the main
-subroutine of a program. C uses the name “main” to identify
+subroutine of a program. 
+\addtoindex{C} uses the name “main” to identify
 the main subprogram of a program. Some other languages provide
 similar or other means to identify the main subprogram of
 a program.}
@@ -250,7 +267,9 @@ of that compilation unit is not valid.
 
 \subsection{Imported Unit Entries}
 \label{chap:importedunitentries}
-The place where a normal or partial unit is imported is
+The 
+\hypertarget{chap:DWATimportimportedunit}
+place where a normal or partial unit is imported is
 represented by a debugging information entry with the 
 tag \livetarg{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit}. 
 An imported unit entry contains a
@@ -323,10 +342,13 @@ those entities.}
 \subsection{Module Entries}
 \label{chap:moduleentries}
 \textit{Several languages have the concept of a ``module.''
+\addtoindexx{Modula-2}
 A Modula\dash 2 definition module may be represented by a module
-entry containing a declaration attribute (\livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration}). A
-Fortran 90 module may also be represented by a module entry
-(but no declaration attribute is warranted because Fortran
+entry containing a 
+\addtoindex{declaration attribute}
+(\livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration}). A
+\addtoindex{Fortran 90} module may also be represented by a module entry
+(but no declaration attribute is warranted because \addtoindex{Fortran}
 has no concept of a corresponding module body).}
 
 A module is represented by a debugging information entry
@@ -352,7 +374,9 @@ have a \livelink{chap:DWATentrypc}{DW\-\_AT\-\_entry\-\_pc} attribute whose valu
 the first executable instruction of that initialization code
 (see Section \refersec{chap:entryaddress}).
 
-If the module has been assigned a priority, it may have a
+If 
+\hypertarget{chap:DWATprioritymodulepriority}
+the module has been assigned a priority, it may have a
 \livelink{chap:DWATpriority}{DW\-\_AT\-\_priority} attribute. The value of this attribute is a
 reference to another debugging information entry describing
 a variable with a constant value. The value of this variable
@@ -361,7 +385,7 @@ represented as it would be on the target architecture.
 
 \subsection{Namespace Entries}
 \label{chap:namespaceentries}
-\textit{C++ has the notion of a namespace, which provides a way to
+\textit{\addtoindex{C++} has the notion of a namespace, which provides a way to
 implement name hiding, so that names of unrelated things
 do not accidentally clash in the global namespace when an
 application is linked together.}
@@ -390,7 +414,8 @@ Namespace and namespace extension entries may own other
 debugging information entries describing program entities
 whose declarations occur in the namespace.
 
-\textit{For C++, such owned program entities may be declarations,
+\textit{For \addtoindex{C++}, such 
+owned program entities may be declarations,
 including certain declarations that are also object or
 function definitions.}
 
@@ -404,13 +429,16 @@ entries with a \livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} attr
 to duplicate information provided by the declaration entry
 referenced by the specification attribute.
 
-\textit{The C++ global namespace (the namespace referred to by
+\textit{The \addtoindex{C++} global namespace
+(the namespace referred to by
 ``::f'', for example) is not explicitly represented in
 DWARF with a namespace entry (thus mirroring the situation
-in C++ source).  Global items may be simply declared with no
+in \addtoindex{C++} source).  
+Global items may be simply declared with no
 reference to a namespace.}
 
-\textit{The C++ compilation unit specific ``unnamed namespace'' may
+\textit{The \addtoindex{C++} 
+compilation unit specific ``unnamed namespace'' may
 be represented by a namespace entry with no name attribute in
 the original namespace declaration entry (and therefore no name
 attribute in any namespace extension entry of this namespace).
@@ -422,18 +450,21 @@ final namespace declaration of a compilation unit; this is a
 quality\dash of\dash implementation issue and no specific requirements
 are given here. If only the final namespace is represented,
 it is impossible for a debugger to interpret using declaration
-references in exactly the manner defined by the C++ language.
+references in exactly the manner defined by the 
+\addtoindex{C++} language.
 }
 
 \textit{Emitting all namespace declaration information in all
 compilation units can result in a significant increase in the
 size of the debug information and significant duplication of
-information across compilation units. The C++ namespace std,
+information across compilation units. 
+The \addtoindex{C++} namespace std,
 for example, is large and will probably be referenced in
-every C++ compilation unit.
+every \addtoindex{C++} compilation unit.
 }
 
-\textit{For a C++ namespace example, see Appendix \refersec{app:namespaceexample}.
+\textit{For a \addtoindex{C++} namespace example, 
+see Appendix \refersec{app:namespaceexample}.
 }
 
 
@@ -446,17 +477,23 @@ module or scope. An imported declaration may sometimes be
 given another name.
 }
 
-An imported declaration is represented by one or
+An 
+imported declaration is represented by one or
+\addtoindex{imported declaration entry}
 more debugging information entries with the 
 tag \livetarg{chap:DWTAGimporteddeclaration}{DW\-\_TAG\-\_imported\-\_declaration}. 
-When an overloaded entity
+When 
+\hypertarget{chap:DWATimportimporteddeclaration}
+an overloaded entity
 is imported, there is one imported declaration entry for
 each overloading. Each imported declaration entry has a
 \livelink{chap:DWATimport}{DW\-\_AT\-\_import} attribute, whose value is a reference to the
 debugging information entry representing the declaration that
 is being imported.
 
-An imported declaration may also have a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+An imported declaration may also have a 
+\livelink{chap:DWATname}{DW\-\_AT\-\_name}
+attribute
 whose value is a null\dash terminated string containing the
 name, as it appears in the source program, by which the
 imported entity is to be known in the context of the imported
@@ -467,10 +504,12 @@ name of the entity being imported.
 
 An imported declaration entry with a name attribute may be
 used as a general means to rename or provide an alias for
+\addtoindexx{alias declaration|see{imported declaration entry}}
 an entity, regardless of the context in which the importing
 declaration or the imported entity occurs.
 
-\textit{A C++ namespace alias may be represented by an imported
+\textit{A \addtoindex{C++} namespace alias may be represented by an imported
+\hypertarget{chap:DWATimportnamespacealias}
 declaration entry with a name attribute whose value is
 a null\dash terminated string containing the alias name as it
 appears in the source program and an import attribute whose
@@ -478,17 +517,19 @@ value is a reference to the applicable original namespace or
 namespace extension entry.
 }
 
-\textit{A C++ using declaration may be represented by one or more
+\textit{A \addtoindex{C++} using declaration may be represented by one or more
+\hypertarget{chap:DWATimportnamespaceusingdeclaration}
 imported declaration entries.  When the using declaration
 refers to an overloaded function, there is one imported
 declaration entry corresponding to each overloading. Each
 imported declaration entry has no name attribute but it does
 have an import attribute that refers to the entry for the
-entity being imported. (C++ provides no means to ``rename''
+entity being imported. (\addtoindex{C++} 
+provides no means to ``rename''
 an imported entity, other than a namespace).
 }
 
-\textit{A Fortran use statement with an ``only list'' may be
+\textit{A \addtoindex{Fortran} use statement with an ``only list'' may be
 represented by a series of imported declaration entries,
 one (or more) for each entity that is imported. An entity
 that is renamed in the importing context may be represented
@@ -522,20 +563,23 @@ name in that module. Any entity in the module that is not
 renamed in this way is known in the context of the imported
 module entry by the same name as it is declared in the module.
 
-\textit{A C++ using directive may be represented by an imported module
+\textit{A \addtoindex{C++} using directive 
+may be represented by an imported module
+\hypertarget{chap:DWATimportnamespaceusingdirective}
 entry, with an import attribute referring to the namespace
 entry of the appropriate extension of the namespace (which
 might be the original namespace entry) and no owned entries.
 }
 
-\textit{A Fortran use statement with a “rename list” may be
+\textit{A \addtoindex{Fortran} use statement with a “rename list” may be
 represented by an imported module entry with an import
 attribute referring to the module and owned entries
 corresponding to those entities that are renamed as part of
 being imported.
 }
 
-\textit{A Fortran use statement with neither a “rename list” nor
+\textit{A \addtoindex{Fortran} use statement 
+with neither a “rename list” nor
 an “only list” may be represented by an imported module
 entry with an import attribute referring to the module and
 no owned child entries.
@@ -546,7 +590,7 @@ series of individual imported declaration entries as described
 in Section \refersec{chap:importedorrenameddeclarationentries}.
 }
 
-\textit{A Fortran use statement for an entity in a module that is
+\textit{A \addtoindex{Fortran} use statement for an entity in a module that is
 itself imported by a use statement without an explicit mention
 may be represented by an imported declaration entry that refers
 to the original debugging information entry. For example, given
@@ -569,7 +613,7 @@ the imported declaration entry for Q within module C refers
 directly to the variable declaration entry for A in module A
 because there is no explicit representation for X in module B.
 
-A similar situation arises for a C++ using declaration that
+A similar situation arises for a \addtoindex{C++} using declaration that
 imports an entity in terms of a namespace alias. See 
 Appendix  \refersec{app:namespaceexample}
 for an example.
@@ -617,7 +661,7 @@ the program.  If more than one subprogram contains this
 \nolink{flag},
 any one of them may be the starting subroutine of the program.
 
-\textit{Fortran has a PROGRAM statement which is used to specify
+\textit{\addtoindex{Fortran} has a PROGRAM statement which is used to specify
 and provide a user\dash supplied name for the main subroutine of
 a program.
 }
@@ -663,13 +707,14 @@ then the debugging information entry for such a subroutine
 may have a calling convention attribute whose value is the
 constant \livetarg{chap:DWCCprogram}{DW\-\_CC\-\_program}.
 
-\textit{The \livelink{chap:DWCCprogram}{DW\-\_CC\-\_program} value is intended to support Fortran main
+\textit{The \livelink{chap:DWCCprogram}{DW\-\_CC\-\_program} value is intended to support \addtoindex{Fortran} main
 programs which in some implementations may not be callable
 or which must be invoked in a special way. It is not intended
 as a way of finding the entry address for the program.
 }
 
-\textit{In C there is a difference between the types of functions
+\textit{In \addtoindex{C}
+there is a difference between the types of functions
 declared using function prototype style declarations and
 those declared using non\dash prototype declarations.
 }
@@ -679,13 +724,15 @@ declaration may have a
 \livelink{chap:DWATprototyped}{DW\-\_AT\-\_prototyped} attribute, which is
 a \livelink{chap:flag}{flag}.
 
-\textit{The Fortran language allows the keywords elemental, pure
+\textit{The \addtoindex{Fortran} 
+language allows the keywords elemental, pure
 and recursive to be included as part of the declaration of
 a subroutine; these attributes reflect that usage. These
 attributes are not relevant for languages that do not support
 similar keywords or syntax. In particular, the \livelink{chap:DWATrecursive}{DW\-\_AT\-\_recursive}
 attribute is neither needed nor appropriate in languages such
-as C where functions support recursion by default.
+as \addtoindex{C} 
+where functions support recursion by default.
 }
 
 A subprogram entry 
@@ -697,12 +744,18 @@ The attribute indicates whether the subroutine
 or entry point was declared with the ``elemental'' keyword
 or property.
 
-A subprogram entry may have a \livelink{chap:DWATpure}{DW\-\_AT\-\_pure} attribute, which is
+A 
+\hypertarget{chap:DWATpurepurepropertyofasubroutine}
+subprogram entry may have a 
+\livelink{chap:DWATpure}{DW\-\_AT\-\_pure} attribute, which is
 a \livelink{chap:flag}{flag}. 
 The attribute indicates whether the subroutine was
 declared with the ``pure'' keyword or property.
 
-A subprogram entry may have a \livelink{chap:DWATrecursive}{DW\-\_AT\-\_recursive} attribute, which
+A 
+\hypertarget{chap:DWATrecursiverecursivepropertyofasubroutine}
+subprogram entry may have a 
+\livelink{chap:DWATrecursive}{DW\-\_AT\-\_recursive} attribute, which
 is a \livelink{chap:flag}{flag}. 
 The attribute indicates whether the subroutine
 or entry point was declared with the ``recursive'' keyword
@@ -713,11 +766,14 @@ or property.
 \subsection{Subroutine and Entry Point Return Types}
 \label{chap:subroutineandentrypointreturntypes}
 
-If the subroutine or entry point is a function that returns a
+If 
+\hypertarget{chap:DWATtypetypeofsubroutinereturn}
+the subroutine or entry point is a function that returns a
 value, then its debugging information entry has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type}
 attribute to denote the type returned by that function.
 
-\textit{Debugging information entries for C void functions should
+\textit{Debugging information entries for 
+\addtoindex{C} void functions should
 not have an attribute for the return type.  }
 
 
@@ -749,7 +805,11 @@ was used before the \livelink{chap:DWATentrypc}{DW\-\_AT\-\_entry\-\_pc} was int
 Version 3). There is insufficient reason to change this.}
 
 
-Subroutines and entry points 
+Subroutines 
+and 
+entry
+\addtoindexx{address class!attribute}
+points 
 \hypertarget{chap:DWATaddressclasssubroutineorsubroutinetype}
 may also have 
 \livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} 
@@ -781,12 +841,15 @@ entries may be interspersed with other entries used by formal
 parameter entries, such as type entries.}
 
 The unspecified parameters of a variable parameter list are
-represented by a debugging information entry with the tag
+represented by a debugging information entry\addtoindexx{unspecified parameters entry}
+with the tag
 \livetarg{chap:DWTAGunspecifiedparameters}{DW\-\_TAG\-\_unspecified\-\_parameters}.
 
 The entry for a subroutine that includes a 
-Fortran \livelink{chap:fortrancommonblock}{common} \livelink{chap:commonblockentry}{block}
-\index{common block|see{Fortran common block}}
+\addtoindex{Fortran} 
+\livelink{chap:fortrancommonblock}{common} 
+\livelink{chap:commonblockentry}{block}
+\addtoindexx{common block|see{Fortran common block}}
 has a child entry with the 
 tag \livetarg{chap:DWTAGcommoninclusion}{DW\-\_TAG\-\_common\-\_inclusion}. 
 The
@@ -800,12 +863,17 @@ for the common \nolink{block} being included
 \subsection{Low-Level Information}
 \label{chap:lowlevelinformation}
 
-A subroutine or entry point entry may have a \livelink{chap:DWATreturnaddr}{DW\-\_AT\-\_return\-\_addr}
+A 
+\hypertarget{chap:DWATreturnaddrsubroutinereturnaddresssavelocation}
+subroutine or entry point entry may have a 
+\livelink{chap:DWATreturnaddr}{DW\-\_AT\-\_return\-\_addr}
 attribute, whose value is a location description. The location
 calculated is the place where the return address for the
 subroutine or entry point is stored.
 
-A subroutine or entry point entry may also have a
+A 
+\hypertarget{chap:DWATframebasesubroutineframebaseaddress}
+subroutine or entry point entry may also have a
 \livelink{chap:DWATframebase}{DW\-\_AT\-\_frame\-\_base} attribute, whose value is a location
 description that computes the “frame base” for the
 subroutine or entry point. If the location description is
@@ -847,8 +915,13 @@ outer subroutine from within an inner subroutine. The
 \livelink{chap:DWATstaticlink}{DW\-\_AT\-\_static\-\_link} and \livelink{chap:DWATframebase}{DW\-\_AT\-\_frame\-\_base} attributes allow
 debuggers to support this same kind of referencing.}
 
-If a subroutine or entry point is nested, it may have a
-\livelink{chap:DWATstaticlink}{DW\-\_AT\-\_static\-\_link} attribute, whose value is a location
+If 
+\hypertarget{chap:DWATstaticlinklocationofuplevelframe}
+a 
+\addtoindexx{address!uplevel|see{static link attribute}}
+subroutine or entry point is nested, it may have a
+\livelink{chap:DWATstaticlink}{DW\-\_AT\-\_static\-\_link}
+attribute, whose value is a location
 description that computes the frame base of the relevant
 instance of the subroutine that immediately encloses the
 subroutine or entry point.
@@ -879,7 +952,7 @@ within the context of the parent.}
 \subsection{Types Thrown by Exceptions}
 \label{chap:typesthrownbyexceptions}
 
-\textit{In C++ a subroutine may declare a set of types which
+\textit{In \addtoindex{C++} a subroutine may declare a set of types which
 it may validly throw.}
 
 If a subroutine explicitly declares that it may throw
@@ -895,7 +968,7 @@ exception that may be thrown.
 \subsection{Function Template Instantiations}
 \label{chap:functiontemplateinstantiations}
 
-\textit{In C++, a function template is a generic definition of
+\textit{In \addtoindex{C++}, a function template is a generic definition of
 a function that is instantiated differently when called with
 values of different types. DWARF does not represent the generic
 template definition, but does represent each instantiation.}
@@ -943,7 +1016,10 @@ artificially by the compiler for this instantiation.
 \subsection{Inlinable and Inlined Subroutines}
 A declaration or a definition of an inlinable subroutine
 is represented by a debugging information entry with the
-tag \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}. The entry for a subroutine that is
+tag 
+\livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}.
+The entry for a subroutine that is
+\hypertarget{chap:DWATinlineinlinedsubroutine}
 explicitly declared to be available for inline expansion or
 that was expanded inline implicitly by the compiler has a
 \livelink{chap:DWATinline}{DW\-\_AT\-\_inline} attribute whose value is an integer constant. The
@@ -966,7 +1042,7 @@ Name&Meaning\\ \hline
 \end{tabular}
 \end{figure}
 
-\textit{In C++, a function or a constructor declared with
+\textit{In \addtoindex{C++}, a function or a constructor declared with
 constexpr is implicitly declared inline. The abstract inline
 instance (see below) is represented by a debugging information
 entry with the tag \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}. Such an entry has a
@@ -976,15 +1052,22 @@ entry with the tag \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}. Suc
 \paragraph{Abstract Instances}
 \label{chap:abstractinstances}
 Any debugging information entry that is owned (either
+\hypertarget{chap:DWATinlineabstracttinstance}
 directly or indirectly) by a debugging information entry
-that contains the \livelink{chap:DWATinline}{DW\-\_AT\-\_inline} attribute is referred to
-as an ``abstract instance entry.'' Any subroutine entry
+that contains the 
+\livelink{chap:DWATinline}{DW\-\_AT\-\_inline} attribute is referred to
+\addtoindexx{abstract instance!entry}
+as an ``abstract instance entry.'' 
+Any subroutine entry
 that contains a \livelink{chap:DWATinline}{DW\-\_AT\-\_inline} attribute whose value is other
-than \livelink{chap:DWINLnotinlined}{DW\-\_INL\-\_not\-\_inlined} is known as 
+than \livelink{chap:DWINLnotinlined}{DW\-\_INL\-\_not\-\_inlined}
+is known as 
+\addtoindexx{abstract instance!root}
 an ``abstract instance root.'' 
 Any set of abstract instance entries that are all
 children (either directly or indirectly) of some abstract
 instance root, together with the root itself, is known as
+\addtoindexx{abstract instance!tree}
 an ``abstract instance tree.'' However, in the case where
 an abstract instance tree is nested within another abstract
 instance tree, the entries in the nested abstract instance
@@ -992,10 +1075,11 @@ tree are not considered to be entries in the outer abstract
 instance tree.
 
 Each abstract instance root is either part of a larger
+\addtoindexx{abstract instance!root}
 tree (which gives a context for the root) or uses
 \livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} to refer to the declaration in context.
 
-\textit{For example, in C++ the context might be a namespace
+\textit{For example, in \addtoindex{C++} the context might be a namespace
 declaration or a class declaration.}
 
 \textit{Abstract instance trees are defined so that no entry is part
@@ -1092,9 +1176,10 @@ representation of the subroutine's return value. The value of
 this attribute is the actual return value of the subroutine,
 represented as it would be on the target architecture.
 
-\textit{In C++, if a function or a constructor declared with constexpr
+\textit{In \addtoindex{C++}, if a function or a constructor declared with constexpr
 is called with constant expressions, then the corresponding
-concrete inlined instance has a \livelink{chap:DWATconstexpr}{DW\-\_AT\-\_const\-\_expr} attribute,
+concrete inlined instance has a 
+\livelink{chap:DWATconstexpr}{DW\-\_AT\-\_const\-\_expr} attribute,
 as well as a \livelink{chap:DWATconstvalue}{DW\-\_AT\-\_const\-\_value} attribute whose value represents
 the actual return value of the concrete inlined instance.}
 
@@ -1131,6 +1216,7 @@ are specific to the concrete instance (but omitted in the
 abstract instance). In place of these omitted attributes, each
 \hypertarget{chap:DWATabstractorigininlineinstance}
 concrete inlined instance entry 
+\addtoindexx{abstract origin attribute}
 has a 
 \livelink{chap:DWATabstractorigin}{DW\-\_AT\-\_abstract\-\_origin}
 attribute that may be used to obtain the missing information
@@ -1139,7 +1225,10 @@ value of the abstract origin attribute is a reference to the
 associated abstract instance entry.
 
 If an entry within a concrete inlined instance tree contains
-attributes describing the declaration coordinates of that
+attributes describing the 
+\addtoindexx{declaration coordinates!in concrete instance}
+declaration coordinates 
+of that
 entry, then those attributes should refer to the file, line
 and column of the original declaration of the subroutine,
 not to the point at which it was inlined. As a consequence,
@@ -1147,6 +1236,7 @@ they may usually be omitted from any entry that has an abstract
 origin attribute.
 
 For each pair of entries that are associated via a
+\addtoindexx{abstract origin attribute}
 \livelink{chap:DWATabstractorigin}{DW\-\_AT\-\_abstract\-\_origin} attribute, both members of the pair
 have the same tag. So, for example, an entry with the tag
 \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable} can only be associated with another entry
@@ -1163,7 +1253,9 @@ tree. There are a few exceptions:
 
 \begin{enumerate}[1.]
 \item An entry in the concrete instance tree may be omitted if
-it contains only a \livelink{chap:DWATabstractorigin}{DW\-\_AT\-\_abstract\-\_origin} attribute and either
+it contains only a 
+\addtoindexx{abstract origin attribute}
+\livelink{chap:DWATabstractorigin}{DW\-\_AT\-\_abstract\-\_origin} attribute and either
 has no children, or its children are omitted. Such entries
 would provide no useful information. In C\dash like languages,
 such entries frequently include types, including structure,
@@ -1191,6 +1283,7 @@ not correspond to entries in the abstract instance tree
 to describe new entities that are specific to a particular
 inlined expansion. In that case, they will not have associated
 entries in the abstract instance tree, should not contain
+\addtoindexx{abstract origin attribute}
 \livelink{chap:DWATabstractorigin}{DW\-\_AT\-\_abstract\-\_origin} attributes, and must contain all their
 own attributes directly. This allows an abstract instance tree
 to omit debugging information entries for anonymous entities
@@ -1208,7 +1301,8 @@ points where those subroutines are actually called. Such
 concrete instances of inlined subroutines are referred to as
 ``concrete out\dash of\dash line instances.''
 
-\textit{In C++, for example, taking the address of a function declared
+\textit{In \addtoindex{C++}, for example, 
+taking the address of a function declared
 to be inline can necessitate the generation of a concrete
 out\dash of\dash line instance of the given function.}
 
@@ -1218,7 +1312,9 @@ concrete inlined instance of that subroutine (as described in
 the preceding section). The representation of such a concrete
 % It is critical that the hypertarget and livelink be
 % separated to avoid problems with latex.
-out\dash of\dash line instance 
+out\dash of\dash line 
+\addtoindexx{abstract origin attribute}
+instance 
 \hypertarget{chap:DWATabstractoriginoutoflineinstance}
 makes use of 
 \livelink{chap:DWATabstractorigin}{DW\-\_AT\-\_abstract\-\_origin}
@@ -1262,6 +1358,8 @@ nested subroutine.
 
 For an inlined subroutine nested within another inlined
 subroutine, the following rules apply to their abstract and
+\addtoindexx{abstract instance!nested}
+\addtoindexx{concrete instance!nested}
 concrete instance trees:
 
 \begin{enumerate}[1.]
@@ -1298,6 +1396,7 @@ for discussion and examples.
 \label{chap:trampolines}
 
 \textit{A trampoline is a compiler\dash generated subroutine that serves as
+\hypertarget{chap:DWATtrampolinetargetsubroutine}
 an intermediary in making a call to another subroutine. It may
 adjust parameters and/or the result (if any) as appropriate
 to the combined calling and called execution contexts.}
@@ -1335,7 +1434,8 @@ The target subprogram may itself be a trampoline. (A sequence
 of trampolines necessarily ends with a non\dash trampoline
 subprogram.)
 
-\textit{In C++, trampolines may be used to implement derived virtual
+\textit{In \addtoindex{C++}, trampolines may be used 
+to implement derived virtual
 member functions; such trampolines typically adjust the
 implicit this pointer parameter in the course of passing
 control.  Other languages and environments may use trampolines
@@ -1364,7 +1464,8 @@ which can be assumed to be the target subroutine. }
 
 \textit{A lexical \livetargi{chap:lexicalblock}{block}{lexical block} is a bracketed sequence of source statements
 that may contain any number of declarations. In some languages
-(including C and C++), \nolink{blocks} can be nested within other
+(including \addtoindex{C} and \addtoindex{C++}),
+\nolink{blocks} can be nested within other
 \nolink{blocks} to any depth.}
 
 % We do not need to link to the preceeding paragraph.
@@ -1393,7 +1494,8 @@ containing the name of the lexical \livelink{chap:lexicalblock}{block}
 as it appears in
 the source program.
 
-\textit{This is not the same as a C or C++ label (see below).}
+\textit{This is not the same as a \addtoindex{C} or 
+\addtoindex{C++} label (see below).}
 
 The lexical \livelink{chap:lexicalblockentry}{block} entry owns 
 debugging information entries that
@@ -1428,14 +1530,17 @@ the name of the label as it appears in the source program.
 \section{With Statement Entries}
 \label{chap:withstatemententries}
 
-\textit{Both Pascal and Modula\dash 2 support the concept of a ``with''
+\textit{Both \addtoindex{Pascal} and 
+\addtoindexx{Modula-2}
+Modula\dash 2 support the concept of a ``with''
 statement. The with statement specifies a sequence of
 executable statements within which the fields of a record
 variable may be referenced, unqualified by the name of the
 record variable.}
 
-A with statement is represented by a debugging information
-entry with the tag \livetarg{chap:DWTAGwithstmt}{DW\-\_TAG\-\_with\-\_stmt}.
+A with statement is represented by a
+\addtoindexi{debugging information entry}{with statement entry}
+with the tag \livetarg{chap:DWTAGwithstmt}{DW\-\_TAG\-\_with\-\_stmt}.
 
 A with statement entry may have either a \livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc} and
 \livelink{chap:DWAThighpc}{DW\-\_AT\-\_high\-\_pc} pair of attributes or a \livelink{chap:DWATranges}{DW\-\_AT\-\_ranges} attribute
@@ -1454,7 +1559,7 @@ the with statement.
 \section{Try and Catch Block Entries}
 \label{chap:tryandcatchblockentries}
 
-\textit{In C++ a lexical \livelink{chap:lexicalblock}{block} may be 
+\textit{In \addtoindex{C++} a lexical \livelink{chap:lexicalblock}{block} may be 
 designated as a ``catch \nolink{block}.'' 
 A catch \livetargi{chap:catchblock}{block}{catch block} is an 
 exception handler that handles
@@ -1484,8 +1589,12 @@ Catch \livelink{chap:catchblock}{block} entries have at
 least one child entry, an
 entry representing the type of exception accepted by
 that catch \livelink{chap:catchblock}{block}. 
-This child entry has one of the tags
-\livelink{chap:DWTAGformalparameter}{DW\-\_TAG\-\_formal\-\_parameter} or \livelink{chap:DWTAGunspecifiedparameters}{DW\-\_TAG\-\_unspecified\-\_parameters},
+
+This child entry has one of the 
+\addtoindexx{unspecified parameters entry!in catch block}
+tags
+\livelink{chap:DWTAGformalparameter}{DW\-\_TAG\-\_formal\-\_parameter} or
+\livelink{chap:DWTAGunspecifiedparameters}{DW\-\_TAG\-\_unspecified\-\_parameters},
 and will have the same form as other parameter entries.
 
 The siblings immediately following