DW_AT_t* through DW_AT_v* attributes table entries done.
[dwarf-doc.git] / dwarf5 / latexdoc / programscope.tex
index b2e846e..408f8ab 100644 (file)
@@ -65,7 +65,8 @@ 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
@@ -80,10 +81,13 @@ default base address for use in location lists (see Section
 (see Section \refersec{chap:noncontiguousaddressranges}).
 
 \item A \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute whose value is a null\dash terminated
-string containing the full or relative path name of the primary
+string 
+\hypertarget{chap:DWATnamepathnameofcompilationsource}
+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 
@@ -95,31 +99,32 @@ Figure \refersec{fig:languagenames}.
 \label{fig:languagenames}
 \begin{tabular}{ll}
 Language name & Meaning\\ \hline
-DW\-\_LANG\-\_Ada83 \dag&ISO Ada:1983 \\
-DW\-\_LANG\-\_Ada95 \dag&ISO Ada:1995 \\
-DW\-\_LANG\-\_C&Non-standardized C, such as K\&R \\
-DW\-\_LANG\-\_C89&ISO C:1989 \\
-DW\-\_LANG\-\_C99 & ISO C:1999 \\
-DW\-\_LANG\-\_C\-\_plus\-\_plus&ISO C++:1998 \\
-DW\-\_LANG\-\_Cobol74& ISO Cobol:1974 \\
-DW\-\_LANG\-\_Cobol85 & ISO Cobol:1985 \\
-DW\-\_LANG\-\_D \dag & D \\
-DW\-\_LANG\-\_Fortran77 &ISO FORTRAN 77\\
-DW\-\_LANG\-\_Fortran90 & ISO Fortran 90\\
-DW\-\_LANG\-\_Fortran95 & ISO Fortran 95\\
-DW\-\_LANG\-\_Java & Java\\
-DW\-\_LANG\-\_Modula2 & ISO Modula\dash 2:1996\\
-DW\-\_LANG\-\_ObjC & Objective C\\
-DW\-\_LANG\-\_ObjC\-\_plus\-\_plus & Objective C++\\
-DW\-\_LANG\-\_Pascal83 & ISO Pascal:1983\\
-DW\-\_LANG\-\_PLI \dag & ANSI PL/I:1976\\
-DW\-\_LANG\-\_Python \dag & Python\\
-DW\-\_LANG\-\_UPC &Unified Parallel C\\ \hline
+\livetarg{chap:DWLANGAda83}{DW\-\_LANG\-\_Ada83} \dag&ISO Ada:1983 \\
+\livetarg{chap:DWLANGAda95}{DW\-\_LANG\-\_Ada95} \dag&ISO Ada:1995 \\
+\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 \\
+\livetarg{chap:DWLANGCplusplus}{DW\-\_LANG\-\_C\-\_plus\-\_plus}&ISO C++:1998 \\
+\livetarg{chap:DWLANGCobol74}{DW\-\_LANG\-\_Cobol74}& ISO Cobol:1974 \\
+\livetarg{chap:DWLANGCobol85}{DW\-\_LANG\-\_Cobol85} & ISO Cobol:1985 \\
+\livetarg{chap:DWLANGD}{DW\-\_LANG\-\_D} \dag & D \\
+\livetarg{chap:DWLANGFortran77}{DW\-\_LANG\-\_Fortran77} &ISO FORTRAN 77\\
+\livetarg{chap:DWLANGFortran90}{DW\-\_LANG\-\_Fortran90} & ISO Fortran 90\\
+\livetarg{chap:DWLANGFortran95}{DW\-\_LANG\-\_Fortran95} & ISO Fortran 95\\
+\livetarg{chap:DWLANGJava}{DW\-\_LANG\-\_Java} & Java\\
+\livetarg{chap:DWLANGModula2}{DW\-\_LANG\-\_Modula2} & ISO Modula\dash 2:1996\\
+\livetarg{chap:DWLANGObjC}{DW\-\_LANG\-\_ObjC} & Objective C\\
+\livetarg{chap:DWLANGObjCplusplus}{DW\-\_LANG\-\_ObjC\-\_plus\-\_plus} & Objective C++\\
+\livetarg{chap:DWLANGPascal83}{DW\-\_LANG\-\_Pascal83} & ISO Pascal:1983\\
+\livetarg{chap:DWLANGPLI}{DW\-\_LANG\-\_PLI} \dag & ANSI PL/I:1976\\
+\livetarg{chap:DWLANGPython}{DW\-\_LANG\-\_Python} \dag & Python\\
+\livetarg{chap:DWLANGUPC}{DW\-\_LANG\-\_UPC} &Unified Parallel C\\ \hline
 \dag \ \ Support for these languages is limited.& \\
 \end{tabular}
 \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
@@ -129,6 +134,7 @@ information for this compilation unit
 (see Section \refersec{chap:linenumberinformation}).
 
 \item A \livelink{chap:DWATmacroinfo}{DW\-\_AT\-\_macro\-\_info} attribute whose value is a section
+\hypertarget{chap:DWATmacroinfomacroinformation}
 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
@@ -137,13 +143,18 @@ the .debug\_macinfo section of the first byte of the macro
 information for this compilation unit 
 (see Section \refersec{chap:macroinformation}).
 
-\item  A \livelink{chap:DWATcompdir}{DW\-\_AT\-\_comp\-\_dir} attribute whose value is a
+\item  A 
+\livelink{chap:DWATcompdir}{DW\-\_AT\-\_comp\-\_dir} 
+attribute 
+\hypertarget{chap:DWATcompdircompilationdirectory}
+whose value is a
 null\dash terminated string containing the current working directory
 of the compilation command that produced this compilation
 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
@@ -151,7 +162,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
@@ -159,43 +172,46 @@ set of identifier case codes is given in Figure
 
 \begin{figure}[here]
 \autorows[0pt]{c}{1}{l}{
-\addtoindex{DW\-\_ID\-\_case\-\_sensitive},
-\addtoindex{DW\-\_ID\-\_up\-\_case},
-\addtoindex{DW\-\_ID\-\_down\-\_case},
-\addtoindex{DW\-\_ID\-\_case\-\_insensitive}
+\livelink{chap:DWIDcasesensitive}{DW\-\_ID\-\_case\-\_sensitive},
+\livelink{chap:DWIDupcase}{DW\-\_ID\-\_up\-\_case},
+\livelink{chap:DWIDdowncase}{DW\-\_ID\-\_down\-\_case},
+\livelink{chap:DWIDcaseinsensitive}{DW\-\_ID\-\_case\-\_insensitive}
 }
 \caption{Identifier case codes}\label{fig:identifiercasecodes}
 \end{figure}
 
-DW\-\_ID\-\_case\-\_sensitive is the default for all compilation units
+\livetarg{chap:DWIDcasesensitive}{DW\-\_ID\-\_case\-\_sensitive} is the default for all compilation units
 that do not have this attribute.  It indicates that names given
 as the values of \livelink{chap:DWATname}{DW\-\_AT\-\_name} attributes in debugging information
 entries for the compilation unit reflect the names as they
 appear in the source program. The debugger should be sensitive
 to the case of identifier names when doing identifier lookups.
 
-DW\-\_ID\-\_up\-\_case means that the producer of the debugging
+\livetarg{chap:DWIDupcase}{DW\-\_ID\-\_up\-\_case} means that the producer of the debugging
 information for this compilation unit converted all source
 names to upper case. The values of the name attributes may not
 reflect the names as they appear in the source program. The
 debugger should convert all names to upper case when doing
 lookups.
 
-DW\-\_ID\-\_down\-\_case means that the producer of the debugging
+\livetarg{chap:DWIDdowncase}{DW\-\_ID\-\_down\-\_case} means that the producer of the debugging
 information for this compilation unit converted all source
 names to lower case. The values of the name attributes may not
 reflect the names as they appear in the source program. The
 debugger should convert all names to lower case when doing
 lookups.
 
-DW\-\_ID\-\_case\-\_insensitive means that the values of the name
+\livetarg{chap:DWIDcaseinsensitive}{DW\-\_ID\-\_case\-\_insensitive} means that the values of the name
 attributes reflect the names as they appear in the source
 program but that a case insensitive lookup should be used to
 access those names.
 
 \item A \livelink{chap:DWATbasetypes}{DW\-\_AT\-\_base\-\_types} attribute whose value is a reference.
 
-This attribute points to a debugging information entry
+
+This 
+\hypertarget{chap:DWATbasetypesprimitivedatatypesofcompilationunit}
+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
@@ -204,20 +220,26 @@ 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 flag whose
+\item A \livelink{chap:DWATuseUTF8}{DW\-\_AT\-\_use\-\_UTF8} attribute, 
+which is a \livelink{chap:flag}{flag} whose
 presence indicates that all strings (such as the names of
 declared entities in the source program) are represented
 using the UTF\dash 8 representation 
 (see Section \refersec{datarep:attributeencodings}).
 
 
-\item A \livelink{chap:DWATmainsubprogram}{DW\-\_AT\-\_main\-\_subprogram} attribute, which is a flag
-whose presence indicates that the compilation unit contains a
+\item A \livelink{chap:DWATmainsubprogram}{DW\-\_AT\-\_main\-\_subprogram} attribute, which is a \livelink{chap:flag}{flag}
+whose presence indicates 
+\hypertarget{chap:DWATmainsubprogramunitcontainingmainorstartingsubprogram}
+that the compilation unit contains a
 subprogram that has been identified as the starting function
 of the program. If more than one compilation unit contains
-this flag, any one of them may contain the starting function.
+this \nolink{flag}, any one of them may contain the starting function.
 
 \textit{Fortran has a PROGRAM statement which is used
 to specify and provide a user\dash specified name for the main
@@ -237,7 +259,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
@@ -333,12 +357,15 @@ whose values encode the contiguous or non\dash contiguous address
 ranges, respectively, of the machine instructions generated for
 the module initialization code 
 (see Section \refersec{chap:codeaddressesandranges}). 
+\hypertarget{chap:DWATentrypcentryaddressofmoduleinitialization}
 It may also
 have a \livelink{chap:DWATentrypc}{DW\-\_AT\-\_entry\-\_pc} attribute whose value is the address of
 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
@@ -356,8 +383,11 @@ A namespace is represented by a debugging information entry
 with the 
 tag \livetarg{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace}. 
 A namespace extension is
-represented by a \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace} entry 
-with a \livelink{chap:DWATextension}{DW\-\_AT\-\_extension}
+\hypertarget{chap:DWATextensionpreviousnamespaceextensionororiginalnamespace}
+represented by a 
+\livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace} entry 
+with a 
+\livelink{chap:DWATextension}{DW\-\_AT\-\_extension}
 attribute referring to the previous extension, or if there
 is no previous extension, to the original 
 \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace}
@@ -432,14 +462,18 @@ given another name.
 An imported declaration is represented by one or
 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
@@ -454,6 +488,7 @@ 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
+\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
@@ -462,6 +497,7 @@ namespace extension entry.
 }
 
 \textit{A 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
@@ -506,6 +542,7 @@ 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
+\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.
@@ -578,19 +615,26 @@ It may also have a \livelink{chap:DWATlinkagename}{DW\-\_AT\-\_linkage\-\_name}
 described in Section \refersec{chap:linkagenames}.
 
 If the name of the subroutine described by an entry with the
-tag \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram} is visible outside of its containing
-compilation unit, that entry has a \livelink{chap:DWATexternal}{DW\-\_AT\-\_external} attribute,
-which is a flag.
+tag \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}
+is visible outside of its containing
+\hypertarget{chap:DWATexternalexternalsubroutine}
+compilation unit, that entry has a 
+\livelink{chap:DWATexternal}{DW\-\_AT\-\_external} attribute,
+which is a \livelink{chap:flag}{flag}.
 
 \textit{Additional attributes for functions that are members of a
 class or structure are described in 
 Section \refersec{chap:memberfunctionentries}.
 }
 
-A subroutine entry may contain a \livelink{chap:DWATmainsubprogram}{DW\-\_AT\-\_main\-\_subprogram}
-attribute which is a flag whose presence indicates that the
+A 
+\hypertarget{chap:DWATmainsubprogrammainorstartingsubprogram}
+subroutine entry may contain a \livelink{chap:DWATmainsubprogram}{DW\-\_AT\-\_main\-\_subprogram}
+attribute which is 
+a \livelink{chap:flag}{flag} whose presence indicates that the
 subroutine has been identified as the starting function of
-the program.  If more than one subprogram contains this flag,
+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
@@ -605,7 +649,10 @@ the standard calling conventions for the target architecture
 and will therefore not be safe to call from within a debugger.
 }
 
-A subroutine entry may contain a \livelink{chap:DWATcallingconvention}{DW\-\_AT\-\_calling\-\_convention}
+A subroutine entry may 
+\hypertarget{chap:DWATcallingconventionsubprogramcallingconvention}
+contain a 
+\livelink{chap:DWATcallingconvention}{DW\-\_AT\-\_calling\-\_convention}
 attribute, whose value is an integer constant. The set of
 calling convention codes is given in 
 Figure \refersec{fig:callingconventioncodes}.
@@ -650,7 +697,7 @@ those declared using non\dash prototype declarations.
 A subroutine entry declared with a function prototype style
 declaration may have a 
 \livelink{chap:DWATprototyped}{DW\-\_AT\-\_prototyped} attribute, which is
-a flag.
+a \livelink{chap:flag}{flag}.
 
 \textit{The Fortran language allows the keywords elemental, pure
 and recursive to be included as part of the declaration of
@@ -661,17 +708,29 @@ attribute is neither needed nor appropriate in languages such
 as C where functions support recursion by default.
 }
 
-A subprogram entry may have a \livelink{chap:DWATelemental}{DW\-\_AT\-\_elemental} attribute, which
-is a flag. The attribute indicates whether the subroutine
+A subprogram entry 
+\hypertarget{chap:DWATelementalelementalpropertyofasubroutine}
+may have a 
+\livelink{chap:DWATelemental}{DW\-\_AT\-\_elemental} attribute, which
+is a \livelink{chap:flag}{flag}. 
+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 flag. The attribute indicates whether the subroutine was
+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
-is a flag. The attribute indicates whether the subroutine
+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
 or property.
 
@@ -680,7 +739,9 @@ 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.
 
@@ -698,7 +759,10 @@ ranges, respectively, of the machine instructions generated
 for the subroutine (see 
 Section \refersec{chap:codeaddressesandranges}).
 
-A subroutine entry may also have a \livelink{chap:DWATentrypc}{DW\-\_AT\-\_entry\-\_pc} attribute
+A 
+\hypertarget{chap:DWATentrypcentryaddressofsubprogram}
+subroutine entry may also have a 
+\livelink{chap:DWATentrypc}{DW\-\_AT\-\_entry\-\_pc} attribute
 whose value is the address of the first executable instruction
 of the subroutine (see 
 Section \refersec{chap:entryaddress}).
@@ -712,8 +776,14 @@ for this purpose, historically the \livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_
 was used before the \livelink{chap:DWATentrypc}{DW\-\_AT\-\_entry\-\_pc} was introduced (in DWARF
 Version 3). There is insufficient reason to change this.}
 
-Subroutines and entry points may also have \livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} and
-\livelink{chap:DWATaddressclass}{DW\-\_AT\-\_address\-\_class} attributes, as appropriate, to specify
+
+Subroutines and entry points 
+\hypertarget{chap:DWATaddressclasssubroutineorsubroutinetype}
+may also have 
+\livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} 
+and
+\livelink{chap:DWATaddressclass}{DW\-\_AT\-\_address\-\_class} attributes,
+as appropriate, to specify
 which segments the code for the subroutine resides in and
 the addressing mode to be used in calling that subroutine.
 
@@ -742,25 +812,33 @@ The unspecified parameters of a variable parameter list are
 represented by a debugging information entry with the tag
 \livetarg{chap:DWTAGunspecifiedparameters}{DW\-\_TAG\-\_unspecified\-\_parameters}.
 
-The entry for a subroutine that includes a Fortran common block
+The entry for a subroutine that includes a 
+Fortran \livelink{chap:fortrancommonblock}{common} \livelink{chap:commonblockentry}{block}
+\index{common block|see{Fortran common block}}
 has a child entry with the 
 tag \livetarg{chap:DWTAGcommoninclusion}{DW\-\_TAG\-\_common\-\_inclusion}. 
 The
+\hypertarget{chap:commonreferencecommonblockusage}
 common inclusion entry has a 
 \livelink{chap:DWATcommonreference}{DW\-\_AT\-\_common\-\_reference} attribute
 whose value is a reference to the debugging information entry
-for the common block being included 
+for the common \nolink{block} being included 
 (see Section \refersec{chap:commonblockentries}).
 
 \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
@@ -802,8 +880,11 @@ 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 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.
@@ -898,7 +979,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
@@ -911,13 +995,13 @@ Figure \refersec{fig:inlinecodes}.
 \label{fig:inlinecodes}
 \begin{tabular}{lp{9cm}}
 Name&Meaning\\ \hline
-DW\-\_INL\-\_not\-\_inlined & Not delared inline nor inlined by the
+\livetarg{chap:DWINLnotinlined}{DW\-\_INL\-\_not\-\_inlined} & Not delared inline nor inlined by the
   compiler(equivalent to the absense of the containing
   \livelink{chap:DWATinline}{DW\-\_AT\-\_inline} attribute) \\
-DW\-\_INL\-\_inlined & Not declared inline but inlined by the compiler \\
-DW\-\_INL\-\_declared\-\_not\-\_inlined & Declared inline but 
+\livetarg{chap:DWINLinlined}{DW\-\_INL\-\_inlined} & Not declared inline but inlined by the compiler \\
+\livetarg{chap:DWINLdeclarednotinlined}{DW\-\_INL\-\_declared\-\_not\-\_inlined} & Declared inline but 
   not inlined by the compiler \\
-DW\-\_INL\-\_declared\-\_inlined & Declared inline and inlined by the compiler \\
+\livetarg{chap:DWINLdeclaredinlined}{DW\-\_INL\-\_declared\-\_inlined} & Declared inline and inlined by the compiler \\
 \end{tabular}
 \end{figure}
 
@@ -925,21 +1009,24 @@ DW\-\_INL\-\_declared\-\_inlined & Declared inline and inlined by the compiler \
 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
-\livelink{chap:DWATinline}{DW\-\_AT\-\_inline} attribute whose value is DW\-\_INL\-\_inlined.}
+\livelink{chap:DWATinline}{DW\-\_AT\-\_inline} attribute whose value is \livelink{chap:DWINLinlined}{DW\-\_INL\-\_inlined}.}
 
 
 \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
+as an ``abstract instance entry.'' Any subroutine entry
 that contains a \livelink{chap:DWATinline}{DW\-\_AT\-\_inline} attribute whose value is other
-than DW\-\_INL\-\_not\-\_inlined is known as an “abstract instance
-root.” Any set of abstract instance entries that are all
+than \livelink{chap:DWINLnotinlined}{DW\-\_INL\-\_not\-\_inlined} is known as 
+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
-an “abstract instance tree.” However, in the case where
+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
 tree are not considered to be entries in the outer abstract
@@ -995,18 +1082,29 @@ Each such entry should be a direct
 child of the entry that represents the scope within which
 the inlining occurs.
 
-Each inlined subroutine entry may have either a \livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc}
+Each inlined subroutine 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 whose values encode the contiguous or non\dash contiguous
 address ranges, respectively, of the machine instructions
 generated for the inlined subroutine (see 
-Section \refersec{chap:codeaddressesandranges}). An
-inlined subroutine entry may also contain a \livelink{chap:DWATentrypc}{DW\-\_AT\-\_entry\-\_pc}
+Section \refersec{chap:codeaddressesandranges}). 
+An
+\hypertarget{chap:DWATentrypcentryaddressofinlinedsubprogram}
+inlined subroutine entry may also contain a 
+\livelink{chap:DWATentrypc}{DW\-\_AT\-\_entry\-\_pc}
 attribute, representing the first executable instruction of
 the inline expansion (see 
 Section \refersec{chap:entryaddress}).
 
-An inlined subroutine entry may also have \livelink{chap:DWATcallfile}{DW\-\_AT\-\_call\-\_file},
+% Positions of the 3 targets here is a bit arbitrary.
+An inlined 
+\hypertarget{chap:DWATcalllinelinenumberofinlinedsubroutinecall}
+subroutine 
+\hypertarget{chap:DWATcallcolumncolumnpositionofinlinedsubroutinecall}
+entry 
+\hypertarget{chap:DWATcallfilefilecontaininginlinedsubroutinecall}
+may also have \livelink{chap:DWATcallfile}{DW\-\_AT\-\_call\-\_file},
 \livelink{chap:DWATcallline}{DW\-\_AT\-\_call\-\_line} and \livelink{chap:DWATcallcolumn}{DW\-\_AT\-\_call\-\_column} attributes, 
 each of whose
 value is an integer constant. These attributes represent the
@@ -1022,8 +1120,12 @@ The call file, call line and call column coordinates do not
 describe the coordinates of the subroutine declaration that
 was inlined, rather they describe the coordinates of the call.
 
-An inlined subroutine entry may have a \livelink{chap:DWATconstexpr}{DW\-\_AT\-\_const\-\_expr}
-attribute, which is a flag whose presence indicates that the
+An inlined subroutine entry 
+\hypertarget{chap:DWATconstexprcompiletimeconstantfunction}
+may have a 
+\livelink{chap:DWATconstexpr}{DW\-\_AT\-\_const\-\_expr}
+attribute, which is a \livelink{chap:flag}{flag} 
+whose presence indicates that the
 subroutine has been evaluated as a compile\dash time constant. Such
 an entry may also have a \livelink{chap:DWATconstvalue}{DW\-\_AT\-\_const\-\_value} attribute,
 whose value may be of any form that is appropriate for the
@@ -1068,7 +1170,10 @@ are not specific to the concrete instance (but present in
 the abstract instance) and need include only attributes that
 are specific to the concrete instance (but omitted in the
 abstract instance). In place of these omitted attributes, each
-concrete inlined instance entry has a \livelink{chap:DWATabstractorigin}{DW\-\_AT\-\_abstract\-\_origin}
+\hypertarget{chap:DWATabstractorigininlineinstance}
+concrete inlined instance entry 
+has a 
+\livelink{chap:DWATabstractorigin}{DW\-\_AT\-\_abstract\-\_origin}
 attribute that may be used to obtain the missing information
 (indirectly) from the associated abstract instance entry. The
 value of the abstract origin attribute is a reference to the
@@ -1152,7 +1257,12 @@ The DWARF representation of a concrete out\dash of\dash line instance
 of an inlined subroutine is essentially the same as for a
 concrete inlined instance of that subroutine (as described in
 the preceding section). The representation of such a concrete
-out\dash of\dash line instance makes use of \livelink{chap:DWATabstractorigin}{DW\-\_AT\-\_abstract\-\_origin}
+% It is critical that the hypertarget and livelink be
+% separated to avoid problems with latex.
+out\dash of\dash line instance 
+\hypertarget{chap:DWATabstractoriginoutoflineinstance}
+makes use of 
+\livelink{chap:DWATabstractorigin}{DW\-\_AT\-\_abstract\-\_origin}
 attributes in exactly the same way as they are used for
 a concrete inlined instance (that is, as references to
 corresponding entries within the associated abstract instance
@@ -1229,6 +1339,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.}
@@ -1256,7 +1367,7 @@ the relocated address of the target subprogram.
 \item If the value is of class string, then the value is the
 (possibly mangled) name of the target subprogram.
 
-\item If the value is of class flag, then the value true
+\item If the value is of class \livelink{chap:flag}{flag}, then the value true
 indicates that the containing subroutine is a trampoline but
 that the target subroutine is not known.
 \end{itemize}
@@ -1293,34 +1404,45 @@ which can be assumed to be the target subroutine. }
 \section{Lexical Block Entries}
 \label{chap:lexicalblockentries}
 
-\textit{A lexical block is a bracketed sequence of source statements
+\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++), blocks can be nested within other
-blocks to any depth.}
+(including C and C++), \nolink{blocks} can be nested within other
+\nolink{blocks} to any depth.}
 
-A lexical block is represented by a debugging information
+% We do not need to link to the preceeding paragraph.
+A lexical \nolink{block} is represented by a debugging information
 entry with the 
 tag \livetarg{chap:DWTAGlexicalblock}{DW\-\_TAG\-\_lexical\-\_block}.
 
-The lexical block 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
+The lexical \livetargi{chap:lexicalblockentry}{block}{lexical block entry} 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
 whose values encode the contiguous or non-contiguous address
 ranges, respectively, of the machine instructions generated
-for the lexical block 
+for the lexical \livelink{chap:lexicalblock}{block} 
 (see Section \refersec{chap:codeaddressesandranges}).
 
-If a name has been given to the lexical block in the source
-program, then the corresponding lexical block entry has a
-\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute whose value is a null-terminated string
-containing the name of the lexical block as it appears in
+If a name has been given to the 
+lexical \livelink{chap:lexicalblock}{block} 
+in the source
+program, then the corresponding 
+lexical \livelink{chap:lexicalblockentry}{block} entry has a
+\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute whose 
+value is a null\dash terminated string
+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).}
 
-The lexical block entry owns debugging information entries that
-describe the declarations within that lexical block. There is
+The lexical \livelink{chap:lexicalblockentry}{block} entry owns 
+debugging information entries that
+describe the declarations within that lexical \livelink{chap:lexicalblock}{block}. 
+There is
 one such debugging information entry for each local declaration
-of an identifier or inner lexical block.
+of an identifier or inner lexical \livelink{chap:lexicalblock}{block}.
 
 \section{Label Entries}
 \label{chap:labelentries}
@@ -1374,33 +1496,43 @@ the with statement.
 \section{Try and Catch Block Entries}
 \label{chap:tryandcatchblockentries}
 
-\textit{In C++ a lexical block may be designated as a ``catch
-block.'' A catch block is an exception handler that handles
-exceptions thrown by an immediately preceding ``try block.''
-A catch block designates the type of the exception that it
+\textit{In 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
+exceptions thrown by an immediately 
+preceding ``try \livelink{chap:tryblock}{block}.''
+A catch \livelink{chap:catchblock}{block} 
+designates the type of the exception that it
 can handle.}
 
-A try block is represented by a debugging information entry
+A try \livetargi{chap:tryblock}{block}{try block} is represented 
+by a debugging information entry
 with the tag \livetarg{chap:DWTAGtryblock}{DW\-\_TAG\-\_try\-\_block}.  
-A catch block is represented by
+A catch \livelink{chap:catchblock}{block} is represented by
 a debugging information entry with 
 the tag \livetarg{chap:DWTAGcatchblock}{DW\-\_TAG\-\_catch\-\_block}.
 
-Both try and catch block entries may have either a
+% nolink as we have links just above and do not have a combo link for both
+Both try and catch \nolink{block} entries 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 whose values encode the contiguous
-or non- contiguous address ranges, respectively, of the
-machine instructions generated for the block (see Section
+or non\dash contiguous address ranges, respectively, of the
+machine instructions generated for the \livelink{chap:lexicalblock}{block}
+(see Section
 \refersec{chap:codeaddressesandranges}).
 
-Catch block entries have at least one child entry, an
+Catch \livelink{chap:catchblock}{block} entries have at 
+least one child entry, an
 entry representing the type of exception accepted by
-that catch block. This child entry has one of the tags
+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},
 and will have the same form as other parameter entries.
 
-The siblings immediately following a try block entry are its
-corresponding catch block entries.
+The siblings immediately following 
+a try \livelink{chap:tryblock}{block} entry are its
+corresponding catch \livelink{chap:catchblock}{block} entries.