Merge branch 'HEAD' of dwarfgit@dwarfstd.org:dwarf-doc.git
[dwarf-doc.git] / dwarf5 / latexdoc / compression.tex
index 6b59415..1aec7b6 100644 (file)
@@ -1,5 +1,5 @@
 \chapter[Compression (Informative)]{DWARF Compression and Duplicate Elimination (Informative)}
 \chapter[Compression (Informative)]{DWARF Compression and Duplicate Elimination (Informative)}
-\label{dwarfcompressionandduplicateeliminationinformative}
+\label{app:dwarfcompressionandduplicateeliminationinformative}
 
 % It seemed difficult to get close to the same layout and 
 % captioning as DWARF4 here with figures as they moved (floated)
 
 % It seemed difficult to get close to the same layout and 
 % captioning as DWARF4 here with figures as they moved (floated)
@@ -11,9 +11,9 @@ can
 \addtoindexx{DWARF duplicate elimination}
 use a lot of disk space.
 
 \addtoindexx{DWARF duplicate elimination}
 use a lot of disk space.
 
-This is especially true for C++, where the depth and complexity
+This is especially true for \addtoindex{C++}, where the depth and complexity
 of headers can mean that many, many (possibly thousands of)
 of headers can mean that many, many (possibly thousands of)
-declarations are repeated in every compilation unit. C++
+declarations are repeated in every compilation unit. \addtoindex{C++}
 templates can also mean that some functions and their DWARF
 descriptions get duplicated.
 
 templates can also mean that some functions and their DWARF
 descriptions get duplicated.
 
@@ -51,28 +51,28 @@ but aside from the DWARF sections, the names are just meant
 to suggest traditional contents as a way of explaining the
 approach, not to be limiting.}
 
 to suggest traditional contents as a way of explaining the
 approach, not to be limiting.}
 
-A traditional relocatable object output 
+A traditional relocatable object output file
 from a single compilation might contain sections 
 named:
 \begin{alltt}
 from a single compilation might contain sections 
 named:
 \begin{alltt}
-    \addtoindex{.data}
-    \addtoindex{.text}
-    \addtoindex{.debug\_info}
-    \addtoindex{.debug\_abbrev}
-    \addtoindex{.debug\_line}
-    \addtoindex{.debug\_aranges}
+    \dotdata{}
+    \dottext{}
+    \dotdebuginfo{}
+    \dotdebugabbrev{}
+    \dotdebugline{}
+    \dotdebugaranges{}
 \end{alltt}
 \end{alltt}
-A relocatable object from a compilation system 
+A relocatable object file from a compilation system 
 attempting duplicate DWARF elimination might
 contain sections as in:
 
 \begin{alltt}
 attempting duplicate DWARF elimination might
 contain sections as in:
 
 \begin{alltt}
-    \addtoindex{.data}
-    \addtoindex{.text}
-    \addtoindex{.debug\_info}
-    \addtoindex{.debug\_abbrev}
-    \addtoindex{.debug\_line}
-    \addtoindex{.debug\_aranges}
+    \dotdata{}
+    \dottext{}
+    \dotdebuginfo{}
+    \dotdebugabbrev{}
+    \dotdebugline{}
+    \dotdebugaranges{}
 \end{alltt}
 
 followed (or preceded, the order is not significant) 
 \end{alltt}
 
 followed (or preceded, the order is not significant) 
@@ -81,27 +81,28 @@ by a series of
 section groups:
 \begin{alltt}
 ==== Section group 1
 section groups:
 \begin{alltt}
 ==== Section group 1
-    \addtoindex{.debug\_info}
-    \addtoindex{.debug\_abbrev}
-    \addtoindex{.debug\_line}
+    \dotdebuginfo{}
+    \dotdebugabbrev{}
+    \dotdebugline{}
 ==== ...
 ==== Section group N
 ==== ...
 ==== Section group N
-    \addtoindex{.debug\_info}
-    \addtoindex{.debug\_abbrev}
-    \addtoindex{.debug\_line}
+    \dotdebuginfo{}
+    \dotdebugabbrev{}
+    \dotdebugline{}
 \end{alltt}
 
 where each \addtoindex{section group} might or might not contain executable
 \end{alltt}
 
 where each \addtoindex{section group} might or might not contain executable
-code (\textit{.text} sections) or data (\textit{.data} sections).
+code (\dottext{} sections) or data (\dotdata{} sections).
 
 
+\needlines{6}
 A \textit{\addtoindex{section group}} is a named set 
 of section contributions
 within an object file with the property that the entire set
 of section contributions must be retained or discarded as a
 whole; no partial elimination is allowed. Section groups can
 generally be handled by a linker in two ways:
 A \textit{\addtoindex{section group}} is a named set 
 of section contributions
 within an object file with the property that the entire set
 of section contributions must be retained or discarded as a
 whole; no partial elimination is allowed. Section groups can
 generally be handled by a linker in two ways:
+\begin{enumerate}[1. ]
 
 
-\begin{enumerate}[1.]
 \item Given multiple identical (duplicate) section groups,
 \addtoindexx{section group}
 one of them is chosen to be kept and used, while the rest
 \item Given multiple identical (duplicate) section groups,
 \addtoindexx{section group}
 one of them is chosen to be kept and used, while the rest
@@ -113,7 +114,6 @@ section outside of the \addtoindex{section group},
 the section group
 is discarded.
 
 the section group
 is discarded.
 
-
 \end{enumerate}
 
 
 \end{enumerate}
 
 
@@ -129,7 +129,7 @@ discard one group and arrange that all references in A.o and
 B.o apply to the remaining one of the two identical section
 groups. This saves space.
 
 B.o apply to the remaining one of the two identical section
 groups. This saves space.
 
-An important part of making it possible to “redirect”
+An important part of making it possible to \doublequote{redirect}
 references to the surviving 
 \addtoindex{section group} is the use of
 consistently chosen linker global symbols for referring to
 references to the surviving 
 \addtoindex{section group} is the use of
 consistently chosen linker global symbols for referring to
@@ -142,26 +142,24 @@ how to match up references and definitions.
 What is minimally needed from the object file format and system
 linker (outside of DWARF itself, and normal object/linker
 facilities such as simple relocations) are:
 What is minimally needed from the object file format and system
 linker (outside of DWARF itself, and normal object/linker
 facilities such as simple relocations) are:
+\begin{enumerate}[1. ]
 
 
-\begin{enumerate}[1.]
-
-\item A means of referencing from inside one \addtoindex{.debug\_info}
-compilation unit to another 
-\addtoindex{.debug\_info} compilation unit
-(\livelink{chap:DWFORMrefaddr}{DW\-\_FORM\-\_ref\-\_addr} provides this).
+\item A means to reference the \dotdebuginfo{} information 
+of one compilation unit from the \dotdebuginfo{} section of 
+another compilation unit (\DWFORMrefaddr{} provides this).
 
 
-\item A means of having multiple contributions to specific sections
-(for example, \addtoindex{.debug\_info}, and so on) in a single object file.
+\item A means to combine multiple contributions to specific sections
+(for example, \dotdebuginfo{}) into a single object file.
 
 
-\item  A means of identifying a \addtoindex{section group} (giving it a name).
+\item  A means to identify a \addtoindex{section group} 
+(giving it a name).
 
 
-\item A means of identifying which sections go together to make
-up a \addtoindex{section group}, 
-so that the group can be treated as a unit
-(kept or discarded).
+\item A means to indicate which sections go together to make
+up a \addtoindex{section group}, so that the group can be 
+treated as a unit (kept or discarded).
 
 
-\item  A means of indicating how each \addtoindex{section group} should be
-processed by the linker.
+\item  A means to indicate how each \addtoindex{section group} 
+should be processed by the linker.
 
 \end{enumerate}
 
 
 \end{enumerate}
 
@@ -170,9 +168,10 @@ corresponds closely to the similarly named concepts in the
 ELF object file representation. 
 The notion of \addtoindex{section group} is
 an abstraction of common extensions of the ELF representation
 ELF object file representation. 
 The notion of \addtoindex{section group} is
 an abstraction of common extensions of the ELF representation
-widely known as ``COMDATs'' or ``COMDAT sections''. (Other
-object file representations provide COMDAT\dash style mechanisms as
-well.) There are several variations in the COMDAT schemes in
+widely known as 
+\doublequote{\COMDAT{}s} or \doublequote{\COMDAT{} sections.} (Other
+object file representations provide \COMDAT{}\dash style mechanisms as
+well.) There are several variations in the \COMDAT{} schemes in
 common use, any of which should be sufficient for the purposes
 of the 
 \addtoindexx{duplication elimination|see{DWARF duplicate elimination}}
 common use, any of which should be sufficient for the purposes
 of the 
 \addtoindexx{duplication elimination|see{DWARF duplicate elimination}}
@@ -191,9 +190,9 @@ Implementations should clearly document their naming conventions.
 
 In the following, it will be helpful to refer to the examples
 in 
 
 In the following, it will be helpful to refer to the examples
 in 
-Figure \ref{app:duplicateeliminationexample1csource}
+Figure \ref{fig:duplicateeliminationexample1csource}
 through 
 through 
-Figure \ref{app:duplicateeliminationexample2companiondwarf}
+Figure \ref{fig:duplicateeliminationexample2companiondwarf}
 of 
 Section \refersec{app:examples}.
 
 of 
 Section \refersec{app:examples}.
 
@@ -215,7 +214,7 @@ is some string specific to the
 producer, which has a language\dash designation embedded in the
 name when appropriate. (Alternatively, the language name
 could be embedded in the 
 producer, which has a language\dash designation embedded in the
 name when appropriate. (Alternatively, the language name
 could be embedded in the 
-\textless gid\dash number \textgreater).
+\textless gid\dash number\textgreater).
 
 
 \item  [\textless file\dash designator\textgreater]
 
 
 \item  [\textless file\dash designator\textgreater]
@@ -234,7 +233,7 @@ the same
 \textless gid\dash number\textgreater,
 and
 
 \textless gid\dash number\textgreater,
 and
 
-\item  a non\dash matching output (say because of \#defines)
+\item  a non-matching output (say because of \texttt{\#defines})
 generates a different 
 \textless gid\dash number\textgreater.
 \end{itemize}
 generates a different 
 \textless gid\dash number\textgreater.
 \end{itemize}
@@ -244,22 +243,22 @@ generates a different
 \textit{It may be useful to think of a 
 \textless gid\dash number\textgreater
 as a kind
 \textit{It may be useful to think of a 
 \textless gid\dash number\textgreater
 as a kind
-of ``digital signature'' that allows a fast test for the
+of \doublequote{digital signature} that allows a fast test for the
 equality of two 
 \addtoindexx{section group}
 section groups.}
 
 So, for example, the \addtoindex{section group} 
 corresponding to file wa.h
 equality of two 
 \addtoindexx{section group}
 section groups.}
 
 So, for example, the \addtoindex{section group} 
 corresponding to file wa.h
-above is given the name \textit{my.compiler.company.cpp.wa.h.123456}.
-
+above is given the name \texttt{my.compiler.company.cpp.wa.h.123456}.
 
 
 
 
+\needlines{4}
 \textbf{Debugging Information Entry Names}
 
 Global labels for 
 \addtoindexx{debugging information entry!ownership relation}
 \textbf{Debugging Information Entry Names}
 
 Global labels for 
 \addtoindexx{debugging information entry!ownership relation}
-debugging information entries (need explained
+debugging information entries (the need for which is explained
 below) within a \addtoindex{section group}
 can be given names of the form
 
 below) within a \addtoindex{section group}
 can be given names of the form
 
@@ -293,14 +292,14 @@ during compilation.
 In general, every point in the 
 \addtoindexx{section group}
 section group 
 In general, every point in the 
 \addtoindexx{section group}
 section group 
-\addtoindex{.debug\_info} that
-could be referenced from outside by any compilation unit must
+\dotdebuginfo{} that
+could be referenced from outside by \emph{any} compilation unit must
 normally have an external name generated for it in the linker
 symbol table, whether the current compilation references all
 those points or not.
 
 normally have an external name generated for it in the linker
 symbol table, whether the current compilation references all
 those points or not.
 
-The completeness of the set of names generated is a
-quality\dash of\dash implementation issue.
+\textit{The completeness of the set of names generated is a
+quality-of-implementation issue.}
 
 It is up to the producer to ensure that if 
 \textless die\dash numbers\textgreater\ 
 
 It is up to the producer to ensure that if 
 \textless die\dash numbers\textgreater\ 
@@ -324,41 +323,41 @@ relocations).
 (This is a consequence of separate compilation, not a rule
 imposed by this document.)
 
 (This is a consequence of separate compilation, not a rule
 imposed by this document.)
 
-\textit{Local labels use references with form \livelink{chap:DWFORMref4}{DW\-\_FORM\-\_ref4}
+\textit{Local labels use references with form \DWFORMreffour{}
 or 
 or 
-\livelink{chap:DWFORMref8}{DW\-\_FORM\-\_ref8}
+\DWFORMrefeight
 (These are affected by relocations
 so 
 (These are affected by relocations
 so 
-\livelink{chap:DWFORMrefudata}{DW\-\_FORM\-\_ref\-\_udata}
-\livelink{chap:DWFORMref1}{DW\-\_FORM\-\_ref1} and 
-\livelink{chap:DWFORMref2}{DW\-\_FORM\-\_ref2} are
+\DWFORMrefudata
+\DWFORMrefone{} and 
+\DWFORMreftwo{} are
 normally not usable and 
 normally not usable and 
-\livelink{chap:DWFORMrefaddr}{DW\-\_FORM\-\_ref\-\_addr} is not necessary
+\DWFORMrefaddr{} is not necessary
 for a local label.)}
 
 for a local label.)}
 
-% This should be a subsubsubsection header but that does work...
-\textbf{Use of \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit} versus 
-\livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit}}
+
+\subsubsection{Use of \addtoindex{DW\_TAG\_compile\_unit} versus 
+\addtoindex{DW\_TAG\_partial\_unit}}
 
 A \addtoindex{section group} compilation unit that uses 
 
 A \addtoindex{section group} compilation unit that uses 
-\livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}
+\DWTAGcompileunit{}
 is like any other compilation unit, in that its contents
 are evaluated by consumers as though it were an ordinary
 compilation unit.
 
 An \#include directive appearing outside any other
 declarations is a good candidate to be represented using
 is like any other compilation unit, in that its contents
 are evaluated by consumers as though it were an ordinary
 compilation unit.
 
 An \#include directive appearing outside any other
 declarations is a good candidate to be represented using
-\livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}
+\DWTAGcompileunit
 However, an \#include appearing inside
 a \addtoindex{C++} namespace declaration or a function, for example, is
 not a good candidate because the entities included are not
 necessarily file level entities.
 
 This also applies to \addtoindex{Fortran} INCLUDE lines when declarations
 However, an \#include appearing inside
 a \addtoindex{C++} namespace declaration or a function, for example, is
 not a good candidate because the entities included are not
 necessarily file level entities.
 
 This also applies to \addtoindex{Fortran} INCLUDE lines when declarations
-are included into a procedure or module context.
+are included into a subprogram or module context.
 
 
-Consequently a compiler must use \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} (instead
-of \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}
+Consequently a compiler must use \DWTAGpartialunit{} (instead
+of \DWTAGcompileunit
 in a \addtoindex{section group} 
 whenever the section group 
 contents are not necessarily globally visible. 
 in a \addtoindex{section group} 
 whenever the section group 
 contents are not necessarily globally visible. 
@@ -366,56 +365,60 @@ This
 directs consumers to ignore that compilation unit when scanning
 top level declarations and definitions.
 
 directs consumers to ignore that compilation unit when scanning
 top level declarations and definitions.
 
-The \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} compilation unit will be referenced
+The \DWTAGpartialunit{} compilation unit will be referenced
 from elsewhere and the referencing locations give the
 appropriate context for interpreting the partial compilation
 unit.
 
 from elsewhere and the referencing locations give the
 appropriate context for interpreting the partial compilation
 unit.
 
-A \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} entry may have, as appropriate, any of
-the attributes assigned to a \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}.
+A \DWTAGpartialunit{} entry may have, as appropriate, any of
+the attributes assigned to a \DWTAGcompileunit.
 
 
 
 
-\textbf{Use of \livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit}}
+\subsubsection{Use of DW\_TAG\_imported\_unit}
 
 
-A \livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit} debugging information entry has an
-\livelink{chap:DWATimport}{DW\-\_AT\-\_import} attribute referencing a \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit} or
-\livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} debugging information entry.
+A \DWTAGimportedunit{} debugging information entry has an
+\DWATimport{} attribute referencing a \DWTAGcompileunit{} or
+\DWTAGpartialunit{} debugging information entry.
 
 
-A \livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit} debugging information entry refers
+A \DWTAGimportedunit{} debugging information entry refers
 to a 
 to a 
-\livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit} or 
-\livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} debugging
+\DWTAGcompileunit{} or 
+\DWTAGpartialunit{} debugging
 information entry to specify that the 
 information entry to specify that the 
-\livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit} or
-\livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} contents logically appear at the point
+\DWTAGcompileunit{} or
+\DWTAGpartialunit{} contents logically appear at the point
 of the 
 of the 
-\livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit} entry.
+\DWTAGimportedunit{} entry.
 
 
 
 
-\textbf{Use of \livelink{chap:DWFORMrefaddr}{DW\-\_FORM\-\_ref\-\_addr}}
+\subsubsection{Use of DW\_FORM\_ref\_addr}
 
 Use 
 
 Use 
-\livelink{chap:DWFORMrefaddr}{DW\-\_FORM\-\_ref\-\_addr} to reference from one compilation
+\DWFORMrefaddr{} to reference from one compilation
 unit's debugging information entries to those of another
 compilation unit.
 
 unit's debugging information entries to those of another
 compilation unit.
 
+\needlines{4}
 When referencing into a removable \addtoindex{section group}
 When referencing into a removable \addtoindex{section group}
-\addtoindex{.debug\_info}
-from another \addtoindex{.debug\_info} (from anywhere), the
-\texttt{<prefix>.<file-designator>.<gid-number>.<die-number>}
+\dotdebuginfo{}
+from another \dotdebuginfo{} (from anywhere), the
+\begin{alltt}
+    <prefix>.<file-designator>.<gid-number>.<die-number>
+\end{alltt}
 name should be used for an external symbol and a relocation
 generated based on that name.
 
 name should be used for an external symbol and a relocation
 generated based on that name.
 
-When referencing into a 
+\needlines{4}
+\textit{When referencing into a 
 \addtoindexx{section group}
 non-section group 
 \addtoindexx{section group}
 non-section group 
-\addtoindex{.debug\_info},
-from another \addtoindex{.debug\_info} (from anywhere) 
-\livelink{chap:DWFORMrefaddr}{DW\-\_FORM\-\_ref\-\_addr} is
+\dotdebuginfo{},
+from another \dotdebuginfo{} (from anywhere) 
+\DWFORMrefaddr{} is
 still the form to be used, but a section\dash relative relocation
 generated by use of a non-exported name (often called an
 still the form to be used, but a section\dash relative relocation
 generated by use of a non-exported name (often called an
-``internal name'') may be used for references within the
-same object file.
+\doublequote{internal name}) may be used for references within the
+same object file.}
 
 \subsection{Examples}
 \label{app:examples}
 
 \subsection{Examples}
 \label{app:examples}
@@ -427,17 +430,17 @@ concrete basis for discussion.
 
 In these examples, the focus is on the arrangement of DWARF
 information into sections (specifically the 
 
 In these examples, the focus is on the arrangement of DWARF
 information into sections (specifically the 
-\addtoindex{.debug\_info}
+\dotdebuginfo{}
 section) and the naming conventions used to achieve references
 into 
 \addtoindexx{section group}
 section groups. 
 In practice, all of the examples that
 follow involve DWARF sections other than just 
 section) and the naming conventions used to achieve references
 into 
 \addtoindexx{section group}
 section groups. 
 In practice, all of the examples that
 follow involve DWARF sections other than just 
-\addtoindex{.debug\_info}
-(for example, \addtoindex{.debug\_line}, 
-\addtoindex{.debug\_aranges}, or others);
-however, only the \addtoindex{.debug\_info}
+\dotdebuginfo{}
+(for example, \dotdebugline{}, 
+\dotdebugaranges{}, or others);
+however, only the \dotdebuginfo{}
 section is shown to keep the
 examples compact and easier to read.
 
 section is shown to keep the
 examples compact and easier to read.
 
@@ -447,284 +450,298 @@ the underlying object language is not (and varies from system to system).
 \subsubsection{C++ Example}
 
 The \addtoindex{C++} source 
 \subsubsection{C++ Example}
 
 The \addtoindex{C++} source 
-\addtoindexx{DWARF duplicate elimination!C++ example}
+\addtoindexx{DWARF duplicate elimination!examples}
 in 
 in 
-Section \refersec{app:duplicateeliminationexample1csource}
+Figure \refersec{fig:duplicateeliminationexample1csource}
 is used to illustrate the DWARF
 representation intended to allow duplicate elimination.
 
 is used to illustrate the DWARF
 representation intended to allow duplicate elimination.
 
-\paragraph{Duplicate elimination example 1: C++ Source} 
-\label{app:duplicateeliminationexample1csource}
-
-File wa.h
-
-\begin{lstlisting}
+\begin{figure}[ht]
+\textit{File wa.h}
+\begin{nlnlisting}
 struct A {
    int i;
 };
 struct A {
    int i;
 };
-\end{lstlisting}
-
-File wa.C
-
-\begin{lstlisting}
+\end{nlnlisting}
+\textit{File wa.c}
+\begin{nlnlisting}
 #include "wa.h";
 int
 f(A &a)
 {
     return a.i + 2;
 }
 #include "wa.h";
 int
 f(A &a)
 {
     return a.i + 2;
 }
-\end{lstlisting}
-
+\end{nlnlisting}
+\caption{Duplicate elimination example \#1: C++ Source}
+\label{fig:duplicateeliminationexample1csource}
+\end{figure}
 
 
-section \refersec{app:duplicateeliminationexample1dwarfsectiongroup}
+Figure \refersec{fig:duplicateeliminationexample1dwarfsectiongroup}
 shows the \addtoindex{section group} corresponding to the included file 
 wa.h.
 
 shows the \addtoindex{section group} corresponding to the included file 
 wa.h.
 
-
-\paragraph{Duplicate elimination example 1: DWARF section group} 
-
-\label{app:duplicateeliminationexample1dwarfsectiongroup}
+\begin{figure}
+\begin{dwflisting}
 % FIXME: the DWFORMrefn could use rethinking
 \begin{alltt}
 ==== Section group name:
     my.compiler.company.cpp.wa.h.123456
 % FIXME: the DWFORMrefn could use rethinking
 \begin{alltt}
 ==== Section group name:
     my.compiler.company.cpp.wa.h.123456
-== section \addtoindex{.debug\_info}
-DW.cpp.wa.h.123456.1: ! linker global symbol
-    \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}
-        \livelink{chap:DWATlanguage}{DW\-\_AT\-\_language}(\livelink{chap:DWLANGCplusplus}{DW\-\_LANG\-\_C\-\_plus\-\_plus})
+== section \dotdebuginfo{}
+DW.cpp.wa.h.123456.1:     ! linker global symbol
+    \DWTAGcompileunit
+        \DWATlanguage(\DWLANGCplusplus)
         ...  ! other unit attributes
         ...  ! other unit attributes
-DW.cpp.wa.h.123456.2: ! linker global symbol
-    \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}
-        \livelink{chap:DWATname}{DW\-\_AT\-\_name}("int")
-DW.cpp.wa.h.123456.3: ! linker global symbol
-    \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type}
-        \livelink{chap:DWATname}{DW\-\_AT\-\_name}("A")
-DW.cpp.wa.h.123456.4: ! linker global symbol
-        \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
-        \livelink{chap:DWATname}{DW\-\_AT\-\_name}("i")
-        \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(\livelink{chap:DWFORMrefn}{DW\-\_FORM\-\_refn} to DW.cpp.wa.h.123456.2)
+DW.cpp.wa.h.123456.2:     ! linker global symbol
+    \DWTAGbasetype
+        \DWATname("int")
+DW.cpp.wa.h.123456.3:     ! linker global symbol
+    \DWTAGstructuretype
+        \DWATname("A")
+DW.cpp.wa.h.123456.4:     ! linker global symbol
+        \DWTAGmember
+        \DWATname("i")
+        \DWATtype(\DWFORMrefn to DW.cpp.wa.h.123456.2)
             ! (This is a local reference, so the more
             ! (This is a local reference, so the more
-            ! compact form \livetarg{chap:DWFORMrefn}{DW\-\_FORM\-\_refn} 
-            ! for n 1,2,4, or 8 can be used)
+            ! compact form \DWFORMrefn 
+            ! for n 1,2,4, or 8 can be used)
 \end{alltt}
 \end{alltt}
-
-
-Figure \refersec{app:duplicateeliminationexample1primarycompilationunit}
-shows the ``normal'' DWARF sections, which are not part of
+\end{dwflisting}
+\vspace{2mm}
+\caption{Duplicate elimination example \#1: DWARF section group} 
+\label{fig:duplicateeliminationexample1dwarfsectiongroup}
+\end{figure}
+
+Figure \refersec{fig:duplicateeliminationexample1primarycompilationunit}
+shows the \doublequote{normal} DWARF sections, which are not part of
 any \addtoindex{section group}, 
 and how they make use of the information
 in the \addtoindex{section group} shown above.
 
 any \addtoindex{section group}, 
 and how they make use of the information
 in the \addtoindex{section group} shown above.
 
-\paragraph{Duplicate elimination example 1: primary compilation unit} 
-\label{app:duplicateeliminationexample1primarycompilationunit}
+\begin{figure}
+\begin{dwflisting}
 \begin{alltt}
 \begin{alltt}
-== section .text
+== section \dottext{}
     [generated code for function f]
     [generated code for function f]
-== section \addtoindex{.debug\_info}
-    \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}
-.L1:                   ! local (non-linker) symbol
-        \livelink{chap:DWTAGreferencetype}{DW\-\_TAG\-\_reference\-\_type}
-            \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to DW.cpp.wa.h.123456.3)
-        \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}
-            \livelink{chap:DWATname}{DW\-\_AT\-\_name}("f")
-            \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to DW.cpp.wa.h.123456.2)
-            \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable}
-                \livelink{chap:DWATname}{DW\-\_AT\-\_name}("a")
-                \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to .L1)
+== section \dotdebuginfo{}
+    \DWTAGcompileunit
+.L1:                           ! local (non-linker) symbol
+        \DWTAGreferencetype
+            \DWATtype(reference to DW.cpp.wa.h.123456.3)
+        \DWTAGsubprogram
+            \DWATname("f")
+            \DWATtype(reference to DW.cpp.wa.h.123456.2)
+            \DWTAGvariable
+                \DWATname("a")
+                \DWATtype(reference to .L1)
         ...
 \end{alltt}
         ...
 \end{alltt}
-
-This example uses \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit} for the \addtoindex{section group},
+\end{dwflisting}
+\caption{Duplicate elimination example \#1: primary compilation unit} 
+\label{fig:duplicateeliminationexample1primarycompilationunit}
+\end{figure}
+
+\needlines{4}
+This example uses \DWTAGcompileunit{} 
+for the \addtoindex{section group},
 implying that the contents of the compilation unit are
 globally visible (in accordance with 
 \addtoindex{C++} language rules).
 implying that the contents of the compilation unit are
 globally visible (in accordance with 
 \addtoindex{C++} language rules).
-\livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} is not needed for the same reason.
+\DWTAGpartialunit{} 
+is not needed for the same reason.
+
+\needlines{6}
+\subsubsection{C Example}
+
+The \addtoindex{C++} example 
+\addtoindexx{DWARF duplicate elimination!examples}
+in this Section might appear to be equally
+valid as a \addtoindex{C} example. However, for \addtoindex{C} 
+it is prudent to include a \DWTAGimportedunit{}
+in the primary unit 
+(see Figure \refersec{fig:duplicateeliminationexample1primarycompilationunit})
+as well as an \DWATimport{} attribute that refers to the proper unit
+in the \addtoindex{section group}.
+
+\needlines{4}
+\textit{The \addtoindex{C} rules for consistency of global (file scope) symbols
+across compilations are less strict than for \addtoindex{C++}; inclusion
+of the import unit attribute assures that the declarations of
+the proper \addtoindex{section group} are considered before declarations
+from other compilations.}
+
 
 \subsubsection{Fortran Example}
 
 
 For a \addtoindex{Fortran}
 
 \subsubsection{Fortran Example}
 
 
 For a \addtoindex{Fortran}
-\addtoindexx{DWARF duplicate elimination!Fortran example}
+\addtoindexx{DWARF duplicate elimination!examples}
 example, consider 
 example, consider 
-Figure \refersec{app:duplicateeliminationexample2fortransource}.
-
+Figure \refersec{fig:duplicateeliminationexample2fortransource}.
 
 
-\paragraph{Duplicate elimination example 2: Fortran source} 
-\label{app:duplicateeliminationexample2fortransource}
-
-File CommonStuff.fh
+\begin{figure}[ht]
+\textit{File CommonStuff.f\hspace{1pt}h}
 \addtoindexx{Fortran}
 \addtoindexx{Fortran}
-
-\begin{lstlisting}
+\begin{nlnlisting}
 IMPLICIT INTEGER(A-Z)
 COMMON /Common1/ C(100)
 PARAMETER(SEVEN = 7)
 IMPLICIT INTEGER(A-Z)
 COMMON /Common1/ C(100)
 PARAMETER(SEVEN = 7)
-\end{lstlisting}
-
-File Func.f
-\begin{lstlisting}
+\end{nlnlisting}
 
 
+\textit{File Func.f}
+\begin{nlnlisting}
 FUNCTION FOO (N)
 INCLUDE 'CommonStuff.fh'
 FOO = C(N + SEVEN)
 RETURN
 END
 FUNCTION FOO (N)
 INCLUDE 'CommonStuff.fh'
 FOO = C(N + SEVEN)
 RETURN
 END
-\end{lstlisting}
+\end{nlnlisting}
+\caption{Duplicate elimination example \#2: Fortran source} 
+\label{fig:duplicateeliminationexample2fortransource}
+\end{figure}
 
 
 
 
-Section \refersec{app:duplicateeliminationexample2dwarfsectiongroup}
+Figure \refersec{fig:duplicateeliminationexample2dwarfsectiongroup}
 shows the \addtoindex{section group}
 corresponding to the included file 
 \addtoindexx{Fortran example}
 CommonStuff.fh.
 
 shows the \addtoindex{section group}
 corresponding to the included file 
 \addtoindexx{Fortran example}
 CommonStuff.fh.
 
-\paragraph{Duplicate elimination example 2: DWARF section group}
-\label{app:duplicateeliminationexample2dwarfsectiongroup}
-
+\begin{figure}
+\begin{dwflisting}
 \begin{alltt}
 ==== Section group name:
 
     my.f90.company.f90.CommonStuff.fh.654321
 
 \begin{alltt}
 ==== Section group name:
 
     my.f90.company.f90.CommonStuff.fh.654321
 
-== section \addtoindex{.debug\_info}
+== section \dotdebuginfo{}
 
 DW.myf90.CommonStuff.fh.654321.1:    ! linker global symbol
 
 DW.myf90.CommonStuff.fh.654321.1:    ! linker global symbol
-    \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit}
+    \DWTAGpartialunit
         ! ...compilation unit attributes, including...
         ! ...compilation unit attributes, including...
-        \livelink{chap:DWATlanguage}{DW\-\_AT\-\_language}(\livelink{chap:DWLANGFortran90}{DW\-\_LANG\-\_Fortran90})
-        \livelink{chap:DWATidentifiercase}{DW\-\_AT\-\_identifier\-\_case}(\livelink{chap:DWIDcaseinsensitive}{DW\-\_ID\-\_case\-\_insensitive})
+        \DWATlanguage(\DWLANGFortranninety)
+        \DWATidentifiercase(\DWIDcaseinsensitive)
 
 
-DW.myf90.CommonStuff.fh.654321.2: ! linker global symbol
-3\$: \livelink{chap:DWTAGarraytype}{DW\-\_TAG\-\_array\-\_type}
+DW.myf90.CommonStuff.fh.654321.2:    ! linker global symbol
+3\$: \DWTAGarraytype
         ! unnamed
         ! unnamed
-        \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to DW.f90.F90\$main.f.2)
+        \DWATtype(reference to DW.f90.F90\$main.f.2)
             ! base type INTEGER
             ! base type INTEGER
-        \livelink{chap:DWTAGsubrangetype}{DW\-\_TAG\-\_subrange\-\_type}
-            \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to DW.f90.F90\$main.f.2)
+        \DWTAGsubrangetype
+            \DWATtype(reference to DW.f90.F90\$main.f.2)
                 ! base type INTEGER)
                 ! base type INTEGER)
-            \livelink{chap:DWATlowerbound}{DW\-\_AT\-\_lower\-\_bound}(constant 1)
-            \livelink{chap:DWATupperbound}{DW\-\_AT\-\_upper\-\_bound}(constant 100)
-
-DW.myf90.CommonStuff.fh.654321.3: ! linker global symbol
-    \livelink{chap:DWTAGcommonblock}{DW\-\_TAG\-\_common\-\_block}
-        \livelink{chap:DWATname}{DW\-\_AT\-\_name}("Common1")
-        \livelink{chap:DWATlocation}{DW\-\_AT\-\_location}(Address of common \nolink{block} Common1)
-        \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable}
-            \livelink{chap:DWATname}{DW\-\_AT\-\_name}("C")
-            \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 3\$)
-            \livelink{chap:DWATlocation}{DW\-\_AT\-\_location}(address of C)
-
-DW.myf90.CommonStuff.fh.654321.4: ! linker global symbol
-    \livelink{chap:DWTAGconstant}{DW\-\_TAG\-\_constant}
-        \livelink{chap:DWATname}{DW\-\_AT\-\_name}("SEVEN")
-        \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to DW.f90.F90\$main.f.2)
+            \DWATlowerbound(constant 1)
+            \DWATupperbound(constant 100)
+
+DW.myf90.CommonStuff.fh.654321.3:    ! linker global symbol
+    \DWTAGcommonblock
+        \DWATname("Common1")
+        \DWATlocation(Address of common \nolink{block} Common1)
+        \DWTAGvariable
+            \DWATname("C")
+            \DWATtype(reference to 3\$)
+            \DWATlocation(address of C)
+
+DW.myf90.CommonStuff.fh.654321.4:    ! linker global symbol
+    \DWTAGconstant
+        \DWATname("SEVEN")
+        \DWATtype(reference to DW.f90.F90\$main.f.2)
             ! base type INTEGER
             ! base type INTEGER
-        \livelink{chap:DWATconstvalue}{DW\-\_AT\-\_const\-\_value}(constant 7)
+        \DWATconstvalue(constant 7)
 \end{alltt}
 \end{alltt}
+\end{dwflisting}
+\caption{Duplicate elimination example \#2: DWARF section group}
+\label{fig:duplicateeliminationexample2dwarfsectiongroup}
+\end{figure}
 
 
-Section \refersec{app:duplicateeliminationexample2primaryunit}
+Figure \refersec{fig:duplicateeliminationexample2primaryunit}
 shows the sections for the primary compilation unit.
 
 shows the sections for the primary compilation unit.
 
-
-
-\paragraph{Duplicate elimination example 2: primary unit }
-\label{app:duplicateeliminationexample2primaryunit}
+\begin{figure}
+\begin{dwflisting}
 \begin{alltt}
 \begin{alltt}
-== section .text
+== section \dottext{}
     [code for function Foo]
 
     [code for function Foo]
 
-== section \addtoindex{.debug\_info}
-    \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}
-        \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}
-            \livelink{chap:DWATname}{DW\-\_AT\-\_name}("Foo")
-            \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to DW.f90.F90\$main.f.2)
+== section \dotdebuginfo{}
+    \DWTAGcompileunit
+        \DWTAGsubprogram
+            \DWATname("Foo")
+            \DWATtype(reference to DW.f90.F90\$main.f.2)
                 ! base type INTEGER
                 ! base type INTEGER
-            \livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit}
-                \livelink{chap:DWATimport}{DW\-\_AT\-\_import}(reference to
+            \DWTAGimportedunit
+                \DWATimport(reference to
                     DW.myf90.CommonStuff.fh.654321.1)
                     DW.myf90.CommonStuff.fh.654321.1)
-            \livelink{chap:DWTAGcommoninclusion}{DW\-\_TAG\-\_common\-\_inclusion} ! For Common1
-                \livelink{chap:DWATcommonreference}{DW\-\_AT\-\_common\-\_reference}(reference to
+            \DWTAGcommoninclusion ! For Common1
+                \DWATcommonreference(reference to
                     DW.myf90.CommonStuff.fh.654321.3)
                     DW.myf90.CommonStuff.fh.654321.3)
-            \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable} ! For function result
-                \livelink{chap:DWATname}{DW\-\_AT\-\_name}("Foo")
-                    \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to DW.f90.F90\$main.f.2)
+            \DWTAGvariable ! For function result
+                \DWATname("Foo")
+                    \DWATtype(reference to DW.f90.F90\$main.f.2)
                         ! base type INTEGER
 \end{alltt}
                         ! base type INTEGER
 \end{alltt}
+\end{dwflisting}
+\caption{Duplicate elimination example \#2: primary unit}
+\label{fig:duplicateeliminationexample2primaryunit}
+\end{figure}
 
 A companion main program is shown in 
 
 A companion main program is shown in 
-Section \refersec{app:duplicateeliminationexample2companionsource}
+Figure \refersec{fig:duplicateeliminationexample2companionsource}
 
 
-\paragraph{Duplicate elimination example 2: companion source }
-\label{app:duplicateeliminationexample2companionsource}
-
-File Main.f 
-
-\begin{lstlisting}
+\begin{figure}
+\textit{File Main.f} 
+\begin{nlnlisting}
 INCLUDE 'CommonStuff.fh'
 C(50) = 8
 PRINT *, 'Result = ', FOO(50 - SEVEN)
 END
 INCLUDE 'CommonStuff.fh'
 C(50) = 8
 PRINT *, 'Result = ', FOO(50 - SEVEN)
 END
-\end{lstlisting}
+\end{nlnlisting}
+\caption{Duplicate elimination example \#2: companion source }
+\label{fig:duplicateeliminationexample2companionsource}
+\end{figure}
 
 
+\needlines{3}
 That main program results in an object file that
 contained a duplicate of the \addtoindex{section group} named
 That main program results in an object file that
 contained a duplicate of the \addtoindex{section group} named
-my.f90.company.f90.CommonStuff.fh.654321 
+\texttt{my.f90.company.f90.CommonStuff.fh.654321} 
 corresponding to the
 included file as well as the remainder of the main subprogram
 as shown in 
 corresponding to the
 included file as well as the remainder of the main subprogram
 as shown in 
-Section \refersec{app:duplicateeliminationexample2companiondwarf}.
-
-\paragraph{Duplicate elimination example 2: companion DWARF }
-\label{app:duplicateeliminationexample2companiondwarf}
+Figure \refersec{fig:duplicateeliminationexample2companiondwarf}.
 
 
+\begin{figure}
+\begin{dwflisting}
 \begin{alltt}
 \begin{alltt}
-== section \addtoindex{.debug\_info}
-    \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}
-        \livelink{chap:DWATname}{DW\-\_AT\-\_name}(F90\$main)
-        \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}
-            \livelink{chap:DWATname}{DW\-\_AT\-\_name}("INTEGER")
-            \livelink{chap:DWATencoding}{DW\-\_AT\-\_encoding}(\livelink{chap:DWATEsigned}{DW\-\_ATE\-\_signed})
-            \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size}(...)
-
-        \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}
+== section \dotdebuginfo{}
+    \DWTAGcompileunit
+        \DWATname(F90\$main)
+        \DWTAGbasetype
+            \DWATname("INTEGER")
+            \DWATencoding(\DWATEsigned)
+            \DWATbytesize(...)
+
+        \DWTAGbasetype
             ...
         ...  ! other base types
             ...
         ...  ! other base types
-        \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}
-            \livelink{chap:DWATname}{DW\-\_AT\-\_name}("F90\$main")
-            \livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit}
-                \livelink{chap:DWATimport}{DW\-\_AT\-\_import}(reference to
+        \DWTAGsubprogram
+            \DWATname("F90\$main")
+            \DWTAGimportedunit
+                \DWATimport(reference to
                     DW.myf90.CommonStuff.fh.654321.1)
                     DW.myf90.CommonStuff.fh.654321.1)
-            \livelink{chap:DWTAGcommoninclusion}{DW\-\_TAG\-\_common\-\_inclusion} ! for Common1
-                \livelink{chap:DWATcommonreference}{DW\-\_AT\-\_common\-\_reference}(reference to
+            \DWTAGcommoninclusion ! for Common1
+                \DWATcommonreference(reference to
                     DW.myf90.CommonStuff.fh.654321.3)
             ...
 \end{alltt}
                     DW.myf90.CommonStuff.fh.654321.3)
             ...
 \end{alltt}
+\end{dwflisting}
+\caption{Duplicate elimination example \#2: companion DWARF }
+\label{fig:duplicateeliminationexample2companiondwarf}
+\end{figure}
 
 
-
-This example uses \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} for the \addtoindex{section group}
+This example uses \DWTAGpartialunit{} for the \addtoindex{section group}
 because the included declarations are not independently
 visible as global entities.
 
 
 because the included declarations are not independently
 visible as global entities.
 
 
-\subsubsection{C Example}
-
-The \addtoindex{C} example 
-\addtoindexx{DWARF duplicate elimination!C example}
-in this Section might appear to be equally
-valid as a \addtoindex{C} example. However, it is prudent to include
-a \livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit}
-in the primary unit 
-(see Figure \refersec{app:duplicateeliminationexample1primarycompilationunit})
-with an \livelink{chap:DWATimport}{DW\-\_AT\-\_import} attribute that refers to the proper unit
-in the \addtoindex{section group}.
-
-\textit{The \addtoindex{C} rules for consistency of global (file scope) symbols
-across compilations are less strict than for C++; inclusion
-of the import unit attribute assures that the declarations of
-the proper \addtoindex{section group} are considered before declarations
-from other compilations.}
-
-
 \section{Using Type Units}
 \label{app:usingtypeunits}
 
 \section{Using Type Units}
 \label{app:usingtypeunits}
 
@@ -732,7 +749,7 @@ A large portion of debug information is type information, and
 in a typical compilation environment, many types are duplicated
 many times. One method of controlling the amount of duplication
 is separating each type into a separate 
 in a typical compilation environment, many types are duplicated
 many times. One method of controlling the amount of duplication
 is separating each type into a separate 
-\addtoindex{.debug\_types} section
+\COMDAT{} \dotdebuginfo{} section
 and arranging for the linker to recognize and eliminate
 duplicates at the individual type level.
 
 and arranging for the linker to recognize and eliminate
 duplicates at the individual type level.
 
@@ -745,27 +762,24 @@ implementation, the relocatable object file may contain one
 of each of these debug sections:
 
 \begin{alltt}
 of each of these debug sections:
 
 \begin{alltt}
-\addtoindex{.debug\_abbrev}
-\addtoindex{.debug\_info}
-\addtoindex{.debug\_line}
+\dotdebugabbrev{}
+\dotdebuginfo{}
+\dotdebugline{}
 \end{alltt}
 
 \end{alltt}
 
-and any number of these additional sections:
-
-\begin{alltt}
-\addtoindex{.debug\_types}
-\end{alltt}
+and any number of additional \COMDAT{} \dotdebuginfo{} sections
+containing type units.
 
 
+\needlines{5}
 As discussed in the previous section 
 (Section \refersec{app:usingcompilationunits}), 
 many
 As discussed in the previous section 
 (Section \refersec{app:usingcompilationunits}), 
 many
-linkers today support the concept of a COMDAT group or
-linkonce section. The general idea is that a ``key'' can be
+linkers today support the concept of a \COMDAT{} group or
+linkonce section. The general idea is that a \doublequote{key} can be
 attached to a section or a group of sections, and the linker
 will include only one copy of a \addtoindex{section group}
 (or individual section) for any given key. 
 attached to a section or a group of sections, and the linker
 will include only one copy of a \addtoindex{section group}
 (or individual section) for any given key. 
-For 
-\addtoindex{.debug\_types} sections, the
+For \COMDAT{} \dotdebuginfo{} sections, the
 key is the \addtoindex{type signature}
 formed from the algorithm given in
 Section \refersec{datarep:typesignaturecomputation}.
 key is the \addtoindex{type signature}
 formed from the algorithm given in
 Section \refersec{datarep:typesignaturecomputation}.
@@ -777,448 +791,496 @@ As an example,
 \addtoindexx{type signature!example computation}
 consider a \addtoindex{C++} header file 
 containing the type definitions shown
 \addtoindexx{type signature!example computation}
 consider a \addtoindex{C++} header file 
 containing the type definitions shown
-in Section \refersec{app:typesignatureexamplescsource}.
+in Figure \refersec{fig:typesignatureexamplescsource}.
 
 
-\subsubsection{ Type signature examples: C++ source}
-\label{app:typesignatureexamplescsource}
-\begin{lstlisting}
+\begin{figure}[ht]
+\begin{nlnlisting}
 namespace N {
 
 namespace N {
 
- struct B;
-
- struct C {
-     int x;
-     int y;
- };
-
- class A {
-   public:
-     A(int v);
-     int v();
-   private:
-     int v_;
-     struct A *next;
-     struct B *bp;
-     struct C c;
- };
-
- }
-\end{lstlisting}
+    struct B;
+
+    struct C {
+        int x;
+        int y;
+    };
+
+    class A {
+    public:
+        A(int v);
+        int v();
+    private:
+        int v_;
+        struct A *next;
+        struct B *bp;
+        struct C c;
+    };
+}
+\end{nlnlisting}
+\caption{Type signature examples: C++ source}
+\label{fig:typesignatureexamplescsource}
+\end{figure}
 
 Next, consider one possible representation of the DWARF
 
 Next, consider one possible representation of the DWARF
-information that describes the type “struct C” as shown
+information that describes the type \doublequote{struct C} as shown
 in 
 in 
-\refersec{app:typesignaturecomputation1dwarfrepresentation}:
+\refersec{fig:typesignaturecomputation1dwarfrepresentation}.
 
 
-\subsubsection{Type signature  computation 1: DWARF representation}
-\label{app:typesignaturecomputation1dwarfrepresentation}
+\begin{figure}
+\begin{dwflisting}
 % We keep the : (colon) away from the attribute so tokenizing in the python tools
 % does not result in adding : into the attribute name.
 \begin{alltt}
 % We keep the : (colon) away from the attribute so tokenizing in the python tools
 % does not result in adding : into the attribute name.
 \begin{alltt}
-  \livelink{chap:DWTAGtypeunit}{DW\-\_TAG\-\_type\-\_unit}
-      \livelink{chap:DWATlanguage}{DW\-\_AT\-\_language} : \livelink{chap:DWLANGCplusplus}{DW\-\_LANG\-\_C\-\_plus\-\_plus} (4)
-    \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace}
-        \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "N"
+  \DWTAGtypeunit
+      \DWATlanguage : \DWLANGCplusplus (4)
+    \DWTAGnamespace
+        \DWATname : "N"
 L1:
 L1:
-      \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type}
-          \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "C"
-          \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} : 8
-          \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
-          \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 5
-        \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
-            \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "x"
-            \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
-            \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 6
-            \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L2
-            \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} : 0
-        \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
-            \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "y"
-            \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
-            \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 7
-            \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L2
-            \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} : 4
+      \DWTAGstructuretype
+          \DWATname : "C"
+          \DWATbytesize : 8
+          \DWATdeclfile : 1
+          \DWATdeclline : 5
+        \DWTAGmember
+            \DWATname : "x"
+            \DWATdeclfile : 1
+            \DWATdeclline : 6
+            \DWATtype : reference to L2
+            \DWATdatamemberlocation : 0
+        \DWTAGmember
+            \DWATname : "y"
+            \DWATdeclfile : 1
+            \DWATdeclline : 7
+            \DWATtype : reference to L2
+            \DWATdatamemberlocation : 4
 L2:
 L2:
-     \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}
-         \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} : 4
-         \livelink{chap:DWATencoding}{DW\-\_AT\-\_encoding} : \livelink{chap:DWATEsigned}{DW\-\_ATE\-\_signed}
-         \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "int"
+     \DWTAGbasetype
+         \DWATbytesize : 4
+         \DWATencoding : \DWATEsigned
+         \DWATname : "int"
 \end{alltt}
 \end{alltt}
+\end{dwflisting}
+\caption{Type signature computation \#1: DWARF representation}
+\label{fig:typesignaturecomputation1dwarfrepresentation}
+\end{figure}
 
 
-In computing a signature for the type N::C, flatten the type
+\needlines{3}
+In computing a signature for the type \texttt{N::C}, flatten the type
 \addtoindexx{type signature}
 description into a byte stream according to the procedure
 outlined in 
 Section \refersec{datarep:typesignaturecomputation}.
 The result is shown in 
 \addtoindexx{type signature}
 description into a byte stream according to the procedure
 outlined in 
 Section \refersec{datarep:typesignaturecomputation}.
 The result is shown in 
-Section \refersec{app:typesignaturecomputation1flattenedbytestream}.
-
-\subsubsection{Type signature  computation 1: flattened byte stream}
-\label{app:typesignaturecomputation1flattenedbytestream}
+Figure \refersec{fig:typesignaturecomputation1flattenedbytestream}.
 
 
+\begin{figure}
+\begin{dwflisting}
 \begin{alltt}
 \begin{alltt}
-// Step 2: 'C' \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace} "N"
+// Step 2: 'C' \DWTAGnamespace "N"
 0x43 0x39 0x4e 0x00
 0x43 0x39 0x4e 0x00
-// Step 3: 'D' \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type}
+// Step 3: 'D' \DWTAGstructuretype
 0x44 0x13
 0x44 0x13
-// Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "C"
+// Step 4: 'A' \DWATname \DWFORMstring "C"
 0x41 0x03 0x08 0x43 0x00
 0x41 0x03 0x08 0x43 0x00
-// Step 4: 'A' \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 8
+// Step 4: 'A' \DWATbytesize \DWFORMsdata 8
 0x41 0x0b 0x0d 0x08
 // Step 7: First child ("x")
 0x41 0x0b 0x0d 0x08
 // Step 7: First child ("x")
-    // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
+    // Step 3: 'D' \DWTAGmember
     0x44 0x0d
     0x44 0x0d
-    // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "x"
+    // Step 4: 'A' \DWATname \DWFORMstring "x"
     0x41 0x03 0x08 0x78 0x00
     0x41 0x03 0x08 0x78 0x00
-    // Step 4: 'A' \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 0
+    // Step 4: 'A' \DWATdatamemberlocation \DWFORMsdata 0
     0x41 0x38 0x0d 0x00
     0x41 0x38 0x0d 0x00
-    // Step 6: 'T' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#2)
+    // Step 6: 'T' \DWATtype (type \#2)
     0x54 0x49
     0x54 0x49
-        // Step 3: 'D' \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}
+        // Step 3: 'D' \DWTAGbasetype
         0x44 0x24
         0x44 0x24
-        // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "int"
+        // Step 4: 'A' \DWATname \DWFORMstring "int"
         0x41 0x03 0x08 0x69 0x6e 0x74 0x00
         0x41 0x03 0x08 0x69 0x6e 0x74 0x00
-        // Step 4: 'A' \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 4
+        // Step 4: 'A' \DWATbytesize \DWFORMsdata 4
         0x41 0x0b 0x0d 0x04
         0x41 0x0b 0x0d 0x04
-        // Step 4: 'A' \livelink{chap:DWATencoding}{DW\-\_AT\-\_encoding} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} \livelink{chap:DWATEsigned}{DW\-\_ATE\-\_signed}
+        // Step 4: 'A' \DWATencoding \DWFORMsdata \DWATEsigned
         0x41 0x3e 0x0d 0x05
         0x41 0x3e 0x0d 0x05
-        // Step 7: End of \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type} "int"
+        // Step 7: End of \DWTAGbasetype "int"
         0x00
         0x00
-    // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "x"
+    // Step 7: End of \DWTAGmember "x"
     0x00
 // Step 7: Second child ("y")
     0x00
 // Step 7: Second child ("y")
-    // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
+    // Step 3: 'D' \DWTAGmember
     0x44 0x0d
     0x44 0x0d
-    // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "y"
-    0x41 0x03 0x08 0x78 0x00
-    // Step 4: 'A' \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 4
+    // Step 4: 'A' \DWATname \DWFORMstring "y"
+    0x41 0x03 0x08 0x79 0x00
+    // Step 4: 'A' \DWATdatamemberlocation \DWFORMsdata 4
     0x41 0x38 0x0d 0x04
     0x41 0x38 0x0d 0x04
-    // Step 6: 'R' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#2)
+    // Step 6: 'R' \DWATtype (type \#2)
     0x52 0x49 0x02
     0x52 0x49 0x02
-    // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "y"
+    // Step 7: End of \DWTAGmember "y"
     0x00
     0x00
-// Step 7: End of \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type} "C"
+// Step 7: End of \DWTAGstructuretype "C"
 0x00
 \end{alltt}
 0x00
 \end{alltt}
+\end{dwflisting}
+\caption{Type signature computation \#1: flattened byte stream}
+\label{fig:typesignaturecomputation1flattenedbytestream}
+\end{figure}
 
 
-Running an \addtoindex{MD5 hash} over this byte stream, and taking the
+\needlines{4}
+Running an \MDfive{} hash over this byte stream, and taking the
 low\dash order 64 bits, yields the final signature: 
 0xd28081e8 dcf5070a.
 
 Next, consider a representation of the DWARF information that
 low\dash order 64 bits, yields the final signature: 
 0xd28081e8 dcf5070a.
 
 Next, consider a representation of the DWARF information that
-describes the type ``class A'' as shown in 
-Section \refersec{app:typesignaturecomputation2dwarfrepresentation}.
-
-
-\subsubsection{Type signature  computation 2: DWARF representation}
-\label{app:typesignaturecomputation2dwarfrepresentation}
+describes the type \doublequote{class A} as shown in 
+Figure \refersec{fig:typesignaturecomputation2dwarfrepresentation}.
 
 
+\begin{figure}
+\figurepart{1}{2}
+\begin{dwflisting}
 \begin{alltt}
 \begin{alltt}
-  \livelink{chap:DWTAGtypeunit}{DW\-\_TAG\-\_type\-\_unit}
-      \livelink{chap:DWATlanguage}{DW\-\_AT\-\_language} : \livelink{chap:DWLANGCplusplus}{DW\-\_LANG\-\_C\-\_plus\-\_plus} (4)
-    \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace}
-          \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "N"
+  \DWTAGtypeunit
+      \DWATlanguage : \DWLANGCplusplus (4)
+    \DWTAGnamespace
+        \DWATname : "N"
 L1:
 L1:
-        \livelink{chap:DWTAGclasstype}{DW\-\_TAG\-\_class\-\_type}
-             \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "A"
-             \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} : 20
-             \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
-             \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 10
-           \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
-                \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "v\_"
-                \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
-                \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 15
-                \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L2
-                \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} : 0
-                \livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} : \livelink{chap:DWACCESSprivate}{DW\-\_ACCESS\-\_private}
-          \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
-               \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "next"
-               \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
-               \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 16
-               \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L3
-               \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} : 4
-               \livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} : \livelink{chap:DWACCESSprivate}{DW\-\_ACCESS\-\_private}
-          \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
-               \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "bp"
-               \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
-               \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 17
-               \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L4
-               \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} : 8
-               \livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} : \livelink{chap:DWACCESSprivate}{DW\-\_ACCESS\-\_private}
-          \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
-               \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "c"
-               \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
-               \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 18
-               \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : 0xd28081e8 dcf5070a (signature for struct C)
-               \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} : 12
-               \livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} : \livelink{chap:DWACCESSprivate}{DW\-\_ACCESS\-\_private}
-       \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}
-           \livelink{chap:DWATexternal}{DW\-\_AT\-\_external} : 1
-           \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "A"
-           \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
-           \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 12
-           \livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration} : 1
-        \livelink{chap:DWTAGformalparameter}{DW\-\_TAG\-\_formal\-\_parameter}
-           \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L3
-           \livelink{chap:DWATartificial}{DW\-\_AT\-\_artificial} : 1
-        \livelink{chap:DWTAGformalparameter}{DW\-\_TAG\-\_formal\-\_parameter}
-           \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L2
-       \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}
-           \livelink{chap:DWATexternal}{DW\-\_AT\-\_external} : 1
-           \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "v"
-           \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
-           \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 13
-           \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L2
-           \livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration} : 1
-         \livelink{chap:DWTAGformalparameter}{DW\-\_TAG\-\_formal\-\_parameter}
-           \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L3
-           \livelink{chap:DWATartificial}{DW\-\_AT\-\_artificial} : 1
+        \DWTAGclasstype
+             \DWATname : "A"
+             \DWATbytesize : 20
+             \DWATdeclfile : 1
+             \DWATdeclline : 10
+           \DWTAGmember
+                \DWATname : "v\_"
+                \DWATdeclfile : 1
+                \DWATdeclline : 15
+                \DWATtype : reference to L2
+                \DWATdatamemberlocation : 0
+                \DWATaccessibility : \DWACCESSprivate
+          \DWTAGmember
+               \DWATname : "next"
+               \DWATdeclfile : 1
+               \DWATdeclline : 16
+               \DWATtype : reference to L3
+               \DWATdatamemberlocation : 4
+               \DWATaccessibility : \DWACCESSprivate
+          \DWTAGmember
+               \DWATname : "bp"
+               \DWATdeclfile : 1
+               \DWATdeclline : 17
+               \DWATtype : reference to L4
+               \DWATdatamemberlocation : 8
+               \DWATaccessibility : \DWACCESSprivate
+          \DWTAGmember
+               \DWATname : "c"
+               \DWATdeclfile : 1
+               \DWATdeclline : 18
+               \DWATtype : 0xd28081e8 dcf5070a (signature for struct C)
+               \DWATdatamemberlocation : 12
+               \DWATaccessibility : \DWACCESSprivate
+\end{alltt}
+\end{dwflisting}
+\caption{Type signature computation \#2: DWARF representation}
+\label{fig:typesignaturecomputation2dwarfrepresentation}
+\end{figure}
+
+\begin{figure}
+\figurepart{2}{2}
+\begin{dwflisting}
+\begin{alltt}
+      \DWTAGsubprogram
+           \DWATexternal : 1
+           \DWATname : "A"
+           \DWATdeclfile : 1
+           \DWATdeclline : 12
+           \DWATdeclaration : 1
+        \DWTAGformalparameter
+           \DWATtype : reference to L3
+           \DWATartificial : 1
+        \DWTAGformalparameter
+           \DWATtype : reference to L2
+       \DWTAGsubprogram
+           \DWATexternal : 1
+           \DWATname : "v"
+           \DWATdeclfile : 1
+           \DWATdeclline : 13
+           \DWATtype : reference to L2
+           \DWATdeclaration : 1
+         \DWTAGformalparameter
+           \DWATtype : reference to L3
+           \DWATartificial : 1
 L2:
 L2:
-    \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}
-         \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} : 4
-         \livelink{chap:DWATencoding}{DW\-\_AT\-\_encoding} : \livelink{chap:DWATEsigned}{DW\-\_ATE\-\_signed}
-         \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "int"
+    \DWTAGbasetype
+         \DWATbytesize : 4
+         \DWATencoding : \DWATEsigned
+         \DWATname : "int"
 L3:
 L3:
-    \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type}
-         \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L1
+    \DWTAGpointertype
+         \DWATtype : reference to L1
 L4:
 L4:
-    \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type}
-         \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L5
-    \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace}
-         \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "N"
+    \DWTAGpointertype
+         \DWATtype : reference to L5
+    \DWTAGnamespace
+         \DWATname : "N"
 L5:
 L5:
-       \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type}
-           \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "B"
-           \livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration} : 1
+       \DWTAGstructuretype
+           \DWATname : "B"
+           \DWATdeclaration : 1
 \end{alltt}
 \end{alltt}
-
-In this example, the structure types N::A and N::C have each
+\end{dwflisting}
+\begin{center}
+\vspace{3mm}
+Figure~\ref{fig:typesignaturecomputation2dwarfrepresentation}: Type signature computation \#2: DWARF representation \textit{(concluded)}
+\end{center}
+\end{figure}
+
+In this example, the structure types \texttt{N::A} and \texttt{N::C} have each
 been placed in separate 
 \addtoindexx{type unit}
 been placed in separate 
 \addtoindexx{type unit}
-type units.  For N::A, the actual
+type units.  For \texttt{N::A}, the actual
 definition of the type begins at label L1. The definition
 definition of the type begins at label L1. The definition
-involves references to the int base type and to two pointer
+involves references to the \texttt{int} base type and to two pointer
 types. The information for each of these referenced types is
 also included in this \addtoindex{type unit}, 
 since base types and pointer
 types are trivial types that are not worth the overhead of a
 separate \addtoindex{type unit}. 
 The last pointer type contains a reference
 types. The information for each of these referenced types is
 also included in this \addtoindex{type unit}, 
 since base types and pointer
 types are trivial types that are not worth the overhead of a
 separate \addtoindex{type unit}. 
 The last pointer type contains a reference
-to an incomplete type N::B, which is also included here as
+to an incomplete type \texttt{N::B}, which is also included here as
 a declaration, since the complete type is unknown and its
 signature is therefore unavailable. There is also a reference
 a declaration, since the complete type is unknown and its
 signature is therefore unavailable. There is also a reference
-to N::C, using 
-\livelink{chap:DWFORMrefsig8}{DW\-\_FORM\-\_ref\-\_sig8} to 
-refer to the type signature
-\addtoindexx{type signature}
-for that type.
-
-In computing a signature for the type N::A, flatten the type
-description into a byte stream according to the procedure
-outlined in 
-Section \refersec{datarep:typesignaturecomputation}.
-The result is shown in 
-Section \refersec{app:typesignatureexample2flattenedbytestream}.
-
-\subsubsection{Type signature example 2: flattenedbytestream}
-\label{app:typesignatureexample2flattenedbytestream}
-% DWARF4 had a \livelink{chap:DWATnamespace}{DW_AT_namespace} below, 
-% but this error is fixed here to be \livelink{chap:DWTAGnamespace}{DW_TAG_namespace}.
+to \texttt{N::C}, using 
+\DWFORMrefsigeight{} to refer to the type signature
+\addtoindexx{type signature} for that type.
+
+\begin{figure}
+\figurepart{1}{3}
+\begin{dwflisting}
+% DWARF4 had a \DWATnamespace{} below, 
+% but this error is fixed here to be \DWTAGnamespace.
 \begin{alltt}
 \begin{alltt}
-// Step 2: 'C' \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace} "N"
+// Step 2: 'C' \DWTAGnamespace "N"
 0x43 0x39 0x4e 0x00
 0x43 0x39 0x4e 0x00
-// Step 3: 'D' \livelink{chap:DWTAGclasstype}{DW\-\_TAG\-\_class\-\_type}
+// Step 3: 'D' \DWTAGclasstype
 0x44 0x02
 0x44 0x02
-// Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "A"
+// Step 4: 'A' \DWATname \DWFORMstring "A"
 0x41 0x03 0x08 0x41 0x00
 0x41 0x03 0x08 0x41 0x00
-// Step 4: 'A' \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 20
+// Step 4: 'A' \DWATbytesize \DWFORMsdata 20
 0x41 0x0b 0x0d 0x14
 // Step 7: First child ("v\_")
 0x41 0x0b 0x0d 0x14
 // Step 7: First child ("v\_")
-    // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
+    // Step 3: 'D' \DWTAGmember
     0x44 0x0d
     0x44 0x0d
-    // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "v\_"
+    // Step 4: 'A' \DWATname \DWFORMstring "v\_"
     0x41 0x03 0x08 0x76 0x5f 0x00
     0x41 0x03 0x08 0x76 0x5f 0x00
-    // Step 4: 'A' \livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} \livelink{chap:DWACCESSprivate}{DW\-\_ACCESS\-\_private}
+    // Step 4: 'A' \DWATaccessibility \DWFORMsdata \DWACCESSprivate
     0x41 0x32 0x0d 0x03
     0x41 0x32 0x0d 0x03
-    // Step 4: 'A' \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 0
+    // Step 4: 'A' \DWATdatamemberlocation \DWFORMsdata 0
     0x41 0x38 0x0d 0x00
     0x41 0x38 0x0d 0x00
-    // Step 6: 'T' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#2)
+    // Step 6: 'T' \DWATtype (type \#2)
     0x54 0x49
     0x54 0x49
-        // Step 3: 'D' \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}
+        // Step 3: 'D' \DWTAGbasetype
         0x44 0x24
         0x44 0x24
-        // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "int"
+        // Step 4: 'A' \DWATname \DWFORMstring "int"
         0x41 0x03 0x08 0x69 0x6e 0x74 0x00
         0x41 0x03 0x08 0x69 0x6e 0x74 0x00
-        // Step 4: 'A' \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 4
+        // Step 4: 'A' \DWATbytesize \DWFORMsdata 4
         0x41 0x0b 0x0d 0x04
         0x41 0x0b 0x0d 0x04
-        // Step 4: 'A' \livelink{chap:DWATencoding}{DW\-\_AT\-\_encoding} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} \livelink{chap:DWATEsigned}{DW\-\_ATE\-\_signed}
+        // Step 4: 'A' \DWATencoding \DWFORMsdata \DWATEsigned
         0x41 0x3e 0x0d 0x05
         0x41 0x3e 0x0d 0x05
-        // Step 7: End of \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type} "int"
+        // Step 7: End of \DWTAGbasetype "int"
         0x00
         0x00
-    // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "v\_"
+    // Step 7: End of \DWTAGmember "v\_"
     0x00
 // Step 7: Second child ("next")
     0x00
 // Step 7: Second child ("next")
-    // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
+    // Step 3: 'D' \DWTAGmember
     0x44 0x0d
     0x44 0x0d
-    // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "next"
+    // Step 4: 'A' \DWATname \DWFORMstring "next"
     0x41 0x03 0x08 0x6e 0x65 0x78 0x74 0x00
     0x41 0x03 0x08 0x6e 0x65 0x78 0x74 0x00
-    // Step 4: 'A' \livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} \livelink{chap:DWACCESSprivate}{DW\-\_ACCESS\-\_private}
+    // Step 4: 'A' \DWATaccessibility \DWFORMsdata \DWACCESSprivate
     0x41 0x32 0x0d 0x03
     0x41 0x32 0x0d 0x03
-    // Step 4: 'A' \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 4
+    // Step 4: 'A' \DWATdatamemberlocation \DWFORMsdata 4
     0x41 0x38 0x0d 0x04
     0x41 0x38 0x0d 0x04
-    // Step 6: 'T' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#3)
+\end{alltt}
+\end{dwflisting}
+\caption{Type signature example \#2: flattened byte stream}
+\label{fig:typesignatureexample2flattenedbytestream}
+\end{figure}
+
+\begin{figure}
+\figurepart{2}{3}
+\begin{dwflisting}
+\begin{alltt}    
+    // Step 6: 'T' \DWATtype (type \#3)
     0x54 0x49
     0x54 0x49
-        // Step 3: 'D' \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type}
+        // Step 3: 'D' \DWTAGpointertype
         0x44 0x0f
         0x44 0x0f
-        // Step 5: 'N' \livelink{chap:DWATtype}{DW\-\_AT\-\_type}
+        // Step 5: 'N' \DWATtype
         0x4e 0x49
         0x4e 0x49
-        // Step 5: 'C' \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace} "N" 'E'
+        // Step 5: 'C' \DWTAGnamespace "N" 'E'
         0x43 0x39 0x4e 0x00 0x45
         // Step 5: "A"
         0x41 0x00
         0x43 0x39 0x4e 0x00 0x45
         // Step 5: "A"
         0x41 0x00
-        // Step 7: End of \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type}
+        // Step 7: End of \DWTAGpointertype
         0x00
         0x00
-    // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "next"
+    // Step 7: End of \DWTAGmember "next"
     0x00
 // Step 7: Third child ("bp")
     0x00
 // Step 7: Third child ("bp")
-    // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
+    // Step 3: 'D' \DWTAGmember
     0x44 0x0d
     0x44 0x0d
-    // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "bp"
+    // Step 4: 'A' \DWATname \DWFORMstring "bp"
     0x41 0x03 0x08 0x62 0x70 0x00
     0x41 0x03 0x08 0x62 0x70 0x00
-    // Step 4: 'A' \livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} \livelink{chap:DWACCESSprivate}{DW\-\_ACCESS\-\_private}
+    // Step 4: 'A' \DWATaccessibility \DWFORMsdata \DWACCESSprivate
     0x41 0x32 0x0d 0x03
     0x41 0x32 0x0d 0x03
-    // Step 4: 'A' \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 8
+    // Step 4: 'A' \DWATdatamemberlocation \DWFORMsdata 8
     0x41 0x38 0x0d 0x08
     0x41 0x38 0x0d 0x08
-    // Step 6: 'T' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#4)
+    // Step 6: 'T' \DWATtype (type \#4)
     0x54 0x49
     0x54 0x49
-        // Step 3: 'D' \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type}
-0x44 0x0f
-        // Step 5: 'N' \livelink{chap:DWATtype}{DW\-\_AT\-\_type}
+        // Step 3: 'D' \DWTAGpointertype
+        0x44 0x0f
+        // Step 5: 'N' \DWATtype
         0x4e 0x49
         0x4e 0x49
-        // Step 5: 'C' \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace} "N" 'E'
+        // Step 5: 'C' \DWTAGnamespace "N" 'E'
         0x43 0x39 0x4e 0x00 0x45
         // Step 5: "B"
         0x42 0x00
         0x43 0x39 0x4e 0x00 0x45
         // Step 5: "B"
         0x42 0x00
-        // Step 7: End of \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type}
+        // Step 7: End of \DWTAGpointertype
         0x00
         0x00
-    // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "next"
+    // Step 7: End of \DWTAGmember "next"
     0x00
 // Step 7: Fourth child ("c")
     0x00
 // Step 7: Fourth child ("c")
-    // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
+    // Step 3: 'D' \DWTAGmember
     0x44 0x0d
     0x44 0x0d
-    // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "c"
+    // Step 4: 'A' \DWATname \DWFORMstring "c"
     0x41 0x03 0x08 0x63 0x00
     0x41 0x03 0x08 0x63 0x00
-    // Step 4: 'A' \livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} \livelink{chap:DWACCESSprivate}{DW\-\_ACCESS\-\_private}
+    // Step 4: 'A' \DWATaccessibility \DWFORMsdata \DWACCESSprivate
     0x41 0x32 0x0d 0x03
     0x41 0x32 0x0d 0x03
-    // Step 4: 'A' \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 12
+\end{alltt}
+\end{dwflisting}
+\begin{center}
+\vspace{3mm}
+Figure~\ref{fig:typesignatureexample2flattenedbytestream}: Type signature example \#2: flattened byte stream \textit{(continued)}
+\end{center}
+\end{figure}
+    
+\begin{figure}
+\figurepart{3}{3}
+\begin{dwflisting}
+\begin{alltt}
+    // Step 4: 'A' \DWATdatamemberlocation \DWFORMsdata 12
     0x41 0x38 0x0d 0x0c
     0x41 0x38 0x0d 0x0c
-    // Step 6: 'T' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#5)
+    // Step 6: 'T' \DWATtype (type \#5)
     0x54 0x49
     0x54 0x49
-        // Step 2: 'C' \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace} "N"
+        // Step 2: 'C' \DWTAGnamespace "N"
         0x43 0x39 0x4e 0x00
         0x43 0x39 0x4e 0x00
-        // Step 3: 'D' \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type}
+        // Step 3: 'D' \DWTAGstructuretype
         0x44 0x13
         0x44 0x13
-        // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "C"
+        // Step 4: 'A' \DWATname \DWFORMstring "C"
         0x41 0x03 0x08 0x43 0x00
         0x41 0x03 0x08 0x43 0x00
-        // Step 4: 'A' \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 8
+        // Step 4: 'A' \DWATbytesize \DWFORMsdata 8
         0x41 0x0b 0x0d 0x08
         // Step 7: First child ("x")
         0x41 0x0b 0x0d 0x08
         // Step 7: First child ("x")
-            // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
+            // Step 3: 'D' \DWTAGmember
             0x44 0x0d
             0x44 0x0d
-            // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "x"
+            // Step 4: 'A' \DWATname \DWFORMstring "x"
             0x41 0x03 0x08 0x78 0x00
             0x41 0x03 0x08 0x78 0x00
-            // Step 4: 'A' \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 0
+            // Step 4: 'A' \DWATdatamemberlocation \DWFORMsdata 0
             0x41 0x38 0x0d 0x00
             0x41 0x38 0x0d 0x00
-            // Step 6: 'R' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#2)
+            // Step 6: 'R' \DWATtype (type \#2)
             0x52 0x49 0x02
             0x52 0x49 0x02
-            // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "x"
+            // Step 7: End of \DWTAGmember "x"
             0x00
         // Step 7: Second child ("y")
             0x00
         // Step 7: Second child ("y")
-            // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
+            // Step 3: 'D' \DWTAGmember
             0x44 0x0d
             0x44 0x0d
-            // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "y"
+            // Step 4: 'A' \DWATname \DWFORMstring "y"
             0x41 0x03 0x08 0x79 0x00
             0x41 0x03 0x08 0x79 0x00
-            // Step 4: 'A' \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 4
+            // Step 4: 'A' \DWATdatamemberlocation \DWFORMsdata 4
             0x41 0x38 0x0d 0x04
             0x41 0x38 0x0d 0x04
-            // Step 6: 'R' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#2)
+            // Step 6: 'R' \DWATtype (type \#2)
             0x52 0x49 0x02
             0x52 0x49 0x02
-            // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "y"
+            // Step 7: End of \DWTAGmember "y"
             0x00
             0x00
-        // Step 7: End of \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type} "C"
+        // Step 7: End of \DWTAGstructuretype "C"
         0x00
         0x00
-    // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "c"
+    // Step 7: End of \DWTAGmember "c"
     0x00
 // Step 7: Fifth child ("A")
     0x00
 // Step 7: Fifth child ("A")
-    // Step 3: 'S' \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram} "A"
+    // Step 3: 'S' \DWTAGsubprogram "A"
     0x53 0x2e 0x41 0x00
 // Step 7: Sixth child ("v")
     0x53 0x2e 0x41 0x00
 // Step 7: Sixth child ("v")
-    // Step 3: 'S' \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram} "v"
+    // Step 3: 'S' \DWTAGsubprogram "v"
     0x53 0x2e 0x76 0x00
     0x53 0x2e 0x76 0x00
-// Step 7: End of \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type} "A"
+// Step 7: End of \DWTAGstructuretype "A"
 0x00
 \end{alltt}
 0x00
 \end{alltt}
+\end{dwflisting}
+\begin{center}
+\vspace{3mm}
+Figure~\ref{fig:typesignatureexample2flattenedbytestream}: Type signature example \#2: flattened byte stream \textit{(concluded)}
+\end{center}
+\end{figure}
+
+In computing a signature for the type \texttt{N::A}, flatten the type
+description into a byte stream according to the procedure
+outlined in 
+Section \refersec{datarep:typesignaturecomputation}.
+The result is shown in 
+Figure \refersec{fig:typesignatureexample2flattenedbytestream}.
 
 
-Running an \addtoindex{MD5 hash} over this byte stream, and taking the
+Running an \MDfive{} hash over this byte stream, and taking the
 low-order 64 bits, yields the final signature: 0xd6d160f5
 5589f6e9.
 
 low-order 64 bits, yields the final signature: 0xd6d160f5
 5589f6e9.
 
-
 A source file that includes this header file may declare a
 A source file that includes this header file may declare a
-variable of type N::A, and its DWARF information may look
-that shown in 
-Section \refersec{app:typesignatureexampleusage}.
-
-
-\subsubsection{Type signature example usage}
-\label{app:typesignatureexampleusage}
+variable of type \texttt{N::A}, and its DWARF information may look
+like that shown in 
+Figure \refersec{fig:typesignatureexampleusage}.
 
 
+\begin{figure}[ht]
+\begin{dwflisting}
 \begin{alltt}
 \begin{alltt}
-  \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}
+  \DWTAGcompileunit
   ...
   ...
-  \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}
+  \DWTAGsubprogram
     ...
     ...
-    \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable}
-      \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "a"
-      \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : (signature) 0xd6d160f5 5589f6e9
-      \livelink{chap:DWATlocation}{DW\-\_AT\-\_location} : ...
+    \DWTAGvariable
+      \DWATname : "a"
+      \DWATtype : (signature) 0xd6d160f5 5589f6e9
+      \DWATlocation : ...
     ...
 \end{alltt}
     ...
 \end{alltt}
+\end{dwflisting}
+\caption{Type signature example usage}
+\label{fig:typesignatureexampleusage}
+\end{figure}
 
 \subsection{Type Signature Computation Grammar}
 \label{app:typesignaturecomputationgrammar}
 
 
 \subsection{Type Signature Computation Grammar}
 \label{app:typesignaturecomputationgrammar}
 
-This section
+Figure \refersec{fig:typesignaturecomputationgrammar}
 \addtoindexx{type signature!computation grammar}
 presents a semi-formal grammar that may aid in understanding
 how the bytes of the flattened type description are formed
 \addtoindexx{type signature!computation grammar}
 presents a semi-formal grammar that may aid in understanding
 how the bytes of the flattened type description are formed
-during the type signature computation algorithm of Section
+during the type signature computation algorithm of
 Section \refersec{datarep:typesignaturecomputation}. 
 
 Section \refersec{datarep:typesignaturecomputation}. 
 
+\begin{figure}[ht]
+\begin{dwflisting}
 %FIXME: The index entries here with \addtoindexx are ineffective.
 \begin{alltt}
 signature
     : opt-context debug-entry attributes children
 %FIXME: The index entries here with \addtoindexx are ineffective.
 \begin{alltt}
 signature
     : opt-context debug-entry attributes children
-
-opt-context           // Step 2
+opt-context               // Step 2
     : 'C' tag-code string opt-context
     : empty
     : 'C' tag-code string opt-context
     : empty
-
-debug-entry           // Step 3
+debug-entry               // Step 3
     : 'D' tag-code
     : 'D' tag-code
-
-attributes            // Steps 4, 5, 6
+attributes                // Steps 4, 5, 6
     : attribute attributes
     : empty
     : attribute attributes
     : empty
-
 attribute
     : 'A' at-code form-encoded-value     // Normal attributes
 attribute
     : 'A' at-code form-encoded-value     // Normal attributes
-    : 'N' at-code opt-context 'E' string // Reference to type
-                                         // by name
-    : 'R' at-code back-ref               // Back-reference 
-                                         // to visited type
+    : 'N' at-code opt-context 'E' string // Reference to type by name
+    : 'R' at-code back-ref               // Back-reference to visited type
     : 'T' at-code signature              // Recursive type
     : 'T' at-code signature              // Recursive type
-children             //  Step 7
+children                 //  Step 7
     : child children
     : child children
-    : '0'
-
+    : '\textbackslash{}0'
 child
     : 'S' tag-code string
     : signature
 child
     : 'S' tag-code string
     : signature
@@ -1227,23 +1289,22 @@ tag-code
 at-code
     : <ULEB128>
 form-encoded-value
 at-code
     : <ULEB128>
 form-encoded-value
-    : \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} value \addtoindexx{constant class}
-    : \livelink{chap:DWFORMflag}{DW\-\_FORM\-\_flag} value \addtoindexx{flag class}
-    : \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} string \addtoindexx{string class}
-    : \livelink{chap:DWFORMblock}{DW\-\_FORM\-\_block} \nolink{block} \addtoindexx{block class}
-\livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} \addtoindexx{string class}
-    : 'x08'
-\livelink{chap:DWFORMblock}{DW\-\_FORM\-\_block}  \addtoindexx{block class}
-    : 'x09'
-\livelink{chap:DWFORMflag}{DW\-\_FORM\-\_flag} \addtoindexx{flag class}
-    : 'x0c'
-\livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} \addtoindexx{constant class}
-    : 'x0d'
+    : \DWFORMsdata value \addtoindexx{constant class}
+    : \DWFORMflag value \addtoindexx{flag class}
+    : \DWFORMstring string \addtoindexx{string class}
+    : \DWFORMblock \nolink{block} \addtoindexx{block class}
+\DWFORMstring \addtoindexx{string class}
+    : '\textbackslash{}x08'
+\DWFORMblock  \addtoindexx{block class}
+    : '\textbackslash{}x09'
+\DWFORMflag \addtoindexx{flag class}
+    : '\textbackslash{}x0c'
+\DWFORMsdata \addtoindexx{constant class}
+    : '\textbackslash{}x0d'
 value
     : <SLEB128>
 \nolink{block}
 value
     : <SLEB128>
 \nolink{block}
-    : <ULEB128> <fixed-length-block>
-                      // The ULEB128 gives the length of the \nolink{block}
+    : <ULEB128> <fixed-length-block> // The ULEB128 gives the length of the \nolink{block}
 back-ref
     : <ULEB128>
 string
 back-ref
     : <ULEB128>
 string
@@ -1251,8 +1312,70 @@ string
 empty
     :
 \end{alltt}
 empty
     :
 \end{alltt}
+\end{dwflisting}
+\caption{Type signature computation grammar}
+\label{fig:typesignaturecomputationgrammar}
+\end{figure}
+
+\clearpage
+\subsection{Declarations Completing Non-Defining Declarations}
+\label{app:declarationscompletingnondefiningdeclarations}
+Consider a compilation unit that contains a definition of the member
+function \texttt{N::A::v()} from 
+Figure \refersec{fig:typesignatureexamplescsource}. 
+A possible representation of the
+debug information for this function in the compilation unit is shown
+in Figure \refersec{fig:completingedeclarationofamemberfunctiondwarf}.
+
+\begin{figure}[ht]
+\begin{dwflisting}
+\begin{alltt}
+  \DWTAGnamespace
+      \DWATname{} : "N"
+L1:
+    \DWTAGclasstype
+        \DWATname{} : "A"
+        \DWATdeclaration{} : true
+        \DWATsignature{} : 0xd6d160f5 5589f6e9
+L2:
+      \DWTAGsubprogram
+          \DWATexternal{} : 1
+          \DWATname{} : "v"
+          \DWATdeclfile{} : 1
+          \DWATdeclline{} : 13
+          \DWATtype{} : reference to L3
+          \DWATdeclaration{} : 1
+        \DWTAGformalparameter
+            \DWATtype{} : reference to L4
+            \DWATartificial{} : 1
+...
+L3:
+  \DWTAGbasetype
+      \DWATbytesize{} : 4
+      \DWATencoding{} : \DWATEsigned
+      \DWATname{} : "int"
+...
+L4:
+  \DWTAGpointertype
+      \DWATtype{} : reference to L1
+...
+  \DWTAGsubprogram
+      \DWATspecification{} : reference to L2
+      \DWATdeclfile{} : 2
+      \DWATdeclline{} : 25
+      \DWATlowpc{} : ...
+      \DWAThighpc{} : ...
+    \DWTAGlexicalblock
+    ...
+...
+\end{alltt}
+\end{dwflisting}
+\caption{Completing declaration of a member function: DWARF \mbox{encoding}}
+\label{fig:completingedeclarationofamemberfunctiondwarf}
+\end{figure}
 
 
 
 
+\clearpage
 \section{Summary of Compression Techniques}
 \label{app:summaryofcompressiontechniques}
 \subsection{\#include compression}
 \section{Summary of Compression Techniques}
 \label{app:summaryofcompressiontechniques}
 \subsection{\#include compression}
@@ -1275,7 +1398,7 @@ from the header files above) are put
 \addtoindexx{section group}
 into non-section group
 sections such as the base object file 
 \addtoindexx{section group}
 into non-section group
 sections such as the base object file 
-\addtoindex{.debug\_info} section.
+\dotdebuginfo{} section.
 
 \subsection{Eliminating function duplication}
 \label{app:eliminatingfunctionduplication}
 
 \subsection{Eliminating function duplication}
 \label{app:eliminatingfunctionduplication}
@@ -1283,10 +1406,11 @@ sections such as the base object file
 
 Function templates (C++) result in code for the same template
 instantiation being compiled into multiple archives or
 
 Function templates (C++) result in code for the same template
 instantiation being compiled into multiple archives or
-relocatable objects. The linker wants to keep only one of a
+relocatable object files. The linker wants to keep only one of a
 given entity. The DWARF description, and everything else for
 this function, should be reduced to just a single copy.
 
 given entity. The DWARF description, and everything else for
 this function, should be reduced to just a single copy.
 
+\needlines{5}
 For each such code group (function template in this example)
 the compiler assigns a name for the group which will match
 all other instantiations of this function but match nothing
 For each such code group (function template in this example)
 the compiler assigns a name for the group which will match
 all other instantiations of this function but match nothing
@@ -1299,18 +1423,10 @@ by the static linker are simply discarded.
 
 
 References to other 
 
 
 References to other 
-\addtoindex{.debug\_info} sections follow the approach
-suggested above, but the naming rule might be slightly
-different in that the 
-\begin{alltt}
-<file-designator> 
-\end{alltt}
-should be interpreted
-as a 
-\begin{alltt}
-<function-designator>.
-\end{alltt}
-
+\dotdebuginfo{} sections follow the approach
+suggested above, but the naming rule is slightly
+different in that the \texttt{\textless file-designator\textgreater} 
+should be interpreted as a \texttt{\textless file-designator\textgreater}.
 
 
 \subsection{Single-function-per-DWARF-compilation-unit}
 
 
 \subsection{Single-function-per-DWARF-compilation-unit}
@@ -1330,11 +1446,11 @@ text, data, and DWARF sections.
 
 There will also be a compilation unit that has the file\dash level
 declarations and definitions. Other per\dash function compilation
 
 There will also be a compilation unit that has the file\dash level
 declarations and definitions. Other per\dash function compilation
-unit DWARF information (
-\addtoindex{.debug\_info}) points to this common
-file\dash level compilation unit using \livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit}.
+unit DWARF information (\dotdebuginfo{}) points to this common
+file\dash level compilation unit using 
+\DWTAGimportedunit.
 
 
-Section groups can use \livelink{chap:DWFORMrefaddr}{DW\-\_FORM\-\_ref\-\_addr} and internal labels
+Section groups can use \DWFORMrefaddr{} and internal labels
 (section\dash relative relocations) to refer to the main object
 file sections, as the 
 \addtoindexx{section group}
 (section\dash relative relocations) to refer to the main object
 file sections, as the 
 \addtoindexx{section group}