Merge branch 'HEAD' of dwarfgit@dwarfstd.org:dwarf-doc.git
[dwarf-doc.git] / dwarf5 / latexdoc / compression.tex
index d6e7c33..1aec7b6 100644 (file)
@@ -1,5 +1,5 @@
 \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)
@@ -11,9 +11,9 @@ can
 \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)
-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.
 
@@ -51,114 +51,127 @@ 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.}
 
-A traditional relocatable object output 
+A traditional relocatable object output file
 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}
-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}
-    \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) 
-by a series of section groups:
+by a series of 
+\addtoindexx{section group}
+section groups:
 \begin{alltt}
 ==== Section group 1
-    \addtoindex{.debug\_info}
-    \addtoindex{.debug\_abbrev}
-    \addtoindex{.debug\_line}
+    \dotdebuginfo{}
+    \dotdebugabbrev{}
+    \dotdebugline{}
 ==== ...
 ==== Section group N
-    \addtoindex{.debug\_info}
-    \addtoindex{.debug\_abbrev}
-    \addtoindex{.debug\_line}
+    \dotdebuginfo{}
+    \dotdebugabbrev{}
+    \dotdebugline{}
 \end{alltt}
 
-where each section group might or might not contain executable
-code (\textit{.text} sections) or data (\textit{.data} sections).
+where each \addtoindex{section group} might or might not contain executable
+code (\dottext{} sections) or data (\dotdata{} sections).
 
-A \textit{section group} is a named set of section contributions
+\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:
+\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
 are discarded.
 
-\item Given a section group that is not referenced from any
-section outside of the section group, the section group
+\item Given a \addtoindex{section group} 
+that is not referenced from any
+section outside of the \addtoindex{section group}, 
+the section group
 is discarded.
 
-
 \end{enumerate}
 
 
-Which handling applies may be indicated by the section group
+Which handling applies may be indicated by the 
+\addtoindex{section group}
 itself and/or selection of certain linker options.
 
-For example, if a linker determines that section group 1
-from A.o and section group 3 from B.o are identical, it could
+For example, if a linker determines that 
+\addtoindex{section group} 1
+from A.o and 
+\addtoindex{section group} 3 from B.o are identical, it could
 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.
 
-An important part of making it possible to “redirect”
-references to the surviving section group is the use of
+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
-locations within each section group. It follows that references
+locations within each 
+\addtoindex{section group}.
+It follows that references
 are simply to external names and the linker already knows
 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:
+\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 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 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 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}
 
 \textit{The notion of section and section contribution used here
 corresponds closely to the similarly named concepts in the
-ELF object file representation. The notion of section group is
+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}}
@@ -177,37 +190,39 @@ Implementations should clearly document their naming conventions.
 
 In the following, it will be helpful to refer to the examples
 in 
-Figure \refersec{app:duplicateeliminationexample1csource}
+Figure \ref{fig:duplicateeliminationexample1csource}
 through 
-Figure \refersec{app:duplicateeliminationexample2companiondwarf}
+Figure \ref{fig:duplicateeliminationexample2companiondwarf}
 of 
 Section \refersec{app:examples}.
 
 \textbf{Section Group Names}
 
-Section groups must have a section group name. For the subsequent 
+Section groups must have a \addtoindex{section group} name.
+\addtoindexx{section group!name}
+For the subsequent 
 \addtoindex{C++} example, a name like
-
-<producer-prefix>.<file-designator>.<gid-number>
-
+\begin{alltt}
+    <producer-prefix>.<file-designator>.<gid-number>
+\end{alltt}
 will suffice, where
 
-\begin{itemize}
+\begin{description}
 
-\item  \textless producer\dash prefix \textgreater 
+\item  [\textless producer\dash prefix\textgreater] 
 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 
-\textless gid\dash number \textgreater).
+\textless gid\dash number\textgreater).
 
 
-\item  \textless file\dash designator \textgreater
+\item  [\textless file\dash designator\textgreater]
 names the file, such as wa.h in
 the example.
 
 
-\item  \textless gid\dash number \textgreater
+\item  [\textless gid\dash number\textgreater]
 is a string generated to identify the
 specific wa.h header file in such a way that
 
@@ -215,33 +230,37 @@ specific wa.h header file in such a way that
 
 \item  a 'matching' output from another compile generates
 the same 
-\textless gid\dash number \textgreater,
+\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.
+\textless gid\dash number\textgreater.
 \end{itemize}
 
-\end{itemize}
+\end{description}
 
 \textit{It may be useful to think of a 
-\textless gid\dash number \textgreater
+\textless gid\dash number\textgreater
 as a kind
-of ``digital signature'' that allows a fast test for the
-equality of two section groups.}
-
-So, for example, the section group corresponding to file wa.h
-above is given the name \textit{my.compiler.company.cpp.wa.h.123456}.
+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
+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}
-debugging information entries (need explained
-below) within a section group can be given names of the form
+debugging information entries (the need for which is explained
+below) within a \addtoindex{section group}
+can be given names of the form
 
 \begin{alltt}
     <prefix>.<file-designator>.<gid-number>.<die-number>
@@ -254,141 +273,152 @@ such as
 \end{alltt}
 
 where
-\begin{itemize}
-\item \textless prefix \textgreater\  
+\begin{description}
+\item [\textless prefix\textgreater]  
 distinguishes this as a DWARF debug info name, and should identify the producer
 and, when appropriate, the language.
-\item \textless file\dash designator\textgreater\  
+\item [\textless file\dash designator\textgreater]  
 and 
-\textless gid\dash number \textgreater
+\texttt{\textless gid\dash number\textgreater} 
 are as above.
 
-\item  \textless die\dash number \textgreater
+\item  [\textless die\dash number\textgreater]
 could be a number sequentially assigned 
 to entities (tokens, perhaps) found
 during compilation.
 
-\end{itemize}
+\end{description}
 
-In general, every point in the section group 
-\addtoindex{.debug\_info} that
-could be referenced from outside by any compilation unit must
+In general, every point in the 
+\addtoindexx{section group}
+section group 
+\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.
 
-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 
-<die-numbers>
-\textless die\dash numbers \textgreater
+\textless die\dash numbers\textgreater\ 
 in separate compilations would not match properly then a
 distinct 
-\textless gid\dash number \textgreater
+\textless gid\dash number\textgreater\ 
 is generated.
 
-Note that only section groups that are designated as
+Note that only 
+\addtoindexx{section group}
+section groups that are designated as
 duplicate\dash removal\dash applies actually require the
 \begin{alltt}
     <prefix>.<file-designator>.<gid-number>.<die-number>
 \end{alltt}
 external labels for debugging information entries as all other
-section group sections can use 'local' labels 
+\addtoindex{section group} sections can use 'local' labels 
 (section\dash relative
 relocations).
 
 (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 
-\livelink{chap:DWFORMref8}{DW\-\_FORM\-\_ref8}
+\DWFORMrefeight
 (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 
-\livelink{chap:DWFORMrefaddr}{DW\-\_FORM\-\_ref\-\_addr} is not necessary
+\DWFORMrefaddr{} is not necessary
 for a local label.)}
 
-\textbf{Use of \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit} versus 
-\livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit}}
 
-A section group compilation unit that uses 
-\livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}
+\subsubsection{Use of \addtoindex{DW\_TAG\_compile\_unit} versus 
+\addtoindex{DW\_TAG\_partial\_unit}}
+
+A \addtoindex{section group} compilation unit that uses 
+\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
-\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 Fortran INCLUDE lines when declarations
-are included into a procedure or module context.
+This also applies to \addtoindex{Fortran} INCLUDE lines when declarations
+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}) in a section group whenever the section
-group contents are not necessarily globally visible. This
+Consequently a compiler must use \DWTAGpartialunit{} (instead
+of \DWTAGcompileunit) 
+in a \addtoindex{section group} 
+whenever the section group 
+contents are not necessarily globally visible. 
+This
 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.
 
-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 
-\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 
-\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 
-\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 
-\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.
 
-When referencing into a removable section group 
-\addtoindex{.debug\_info}
-from another \addtoindex{.debug\_info} (from anywhere), the
+\needlines{4}
+When referencing into a removable \addtoindex{section group}
+\dotdebuginfo{}
+from another \dotdebuginfo{} (from anywhere), the
 \begin{alltt}
-<prefix>.<file-designator>.<gid-number>.<die-number>
+    <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.
 
-When referencing into a non-section group 
-\addtoindex{.debug\_info},
-from another \addtoindex{.debug\_info} (from anywhere) 
-\livelink{chap:DWFORMrefaddr}{DW\-\_FORM\-\_ref\-\_addr} is
+\needlines{4}
+\textit{When referencing into a 
+\addtoindexx{section group}
+non-section group 
+\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
-``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}
@@ -400,14 +430,17 @@ concrete basis for discussion.
 
 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 section groups. In practice, all of the examples that
+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.
 
@@ -416,281 +449,299 @@ the underlying object language is not (and varies from system to system).
 
 \subsubsection{C++ Example}
 
-The addtoindex{C++} source 
-\addtoindexx{DWARF duplicate elimination!C++ example}
+The \addtoindex{C++} source 
+\addtoindexx{DWARF duplicate elimination!examples}
 in 
-Section \refersec{app:duplicateeliminationexample1csource}
+Figure \refersec{fig:duplicateeliminationexample1csource}
 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;
 };
-\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;
 }
-\end{lstlisting}
+\end{nlnlisting}
+\caption{Duplicate elimination example \#1: C++ Source}
+\label{fig:duplicateeliminationexample1csource}
+\end{figure}
 
-
-section \refersec{app:duplicateeliminationexample1dwarfsectiongroup}
-shows the section group corresponding to the included file 
+Figure \refersec{fig:duplicateeliminationexample1dwarfsectiongroup}
+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
-== 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
-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
-            ! 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}
-
-
-Figure \refersec{app:duplicateeliminationexample1primarycompilationunit}
-shows the ``normal'' DWARF sections, which are not part of
-any section group, and how they make use of the information
-in the section group shown above.
-
-\paragraph{Duplicate elimination example 1: primary compilation unit} 
-\label{app:duplicateeliminationexample1primarycompilationunit}
+\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.
+
+\begin{figure}
+\begin{dwflisting}
 \begin{alltt}
-== section .text
+== section \dottext{}
     [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}
-
-This example uses \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit} for the 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).
-\livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} is not needed for the same reason.
+\DWTAGpartialunit{} 
+is not needed for the same reason.
 
-\subsubsection{Fortran Example}
+\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}.
 
-For a Fortran 
-\addtoindexx{DWARF duplicate elimination!Fortran example}
-example, consider 
-Figure \refersec{app:duplicateeliminationexample2fortransource}.
+\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.}
 
 
-\paragraph{Duplicate elimination example 2: Fortran source} 
-\label{app:duplicateeliminationexample2fortransource}
+\subsubsection{Fortran Example}
+
 
-File CommonStuff.fh
+For a \addtoindex{Fortran}
+\addtoindexx{DWARF duplicate elimination!examples}
+example, consider 
+Figure \refersec{fig:duplicateeliminationexample2fortransource}.
 
-\begin{lstlisting}
+\begin{figure}[ht]
+\textit{File CommonStuff.f\hspace{1pt}h}
+\addtoindexx{Fortran}
+\begin{nlnlisting}
 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
-\end{lstlisting}
-
+\end{nlnlisting}
+\caption{Duplicate elimination example \#2: Fortran source} 
+\label{fig:duplicateeliminationexample2fortransource}
+\end{figure}
 
-Section \refersec{app:duplicateeliminationexample2dwarfsectiongroup}
-shows the section group 
-corresponding to the included file CommonStuff.fh.
 
-\paragraph{Duplicate elimination example 2: DWARF section group}
-\label{app:duplicateeliminationexample2dwarfsectiongroup}
+Figure \refersec{fig:duplicateeliminationexample2dwarfsectiongroup}
+shows the \addtoindex{section group}
+corresponding to the included file 
+\addtoindexx{Fortran example}
+CommonStuff.fh.
 
+\begin{figure}
+\begin{dwflisting}
 \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
-    \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit}
+    \DWTAGpartialunit
         ! ...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
-        \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
-        \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)
-            \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
-        \livelink{chap:DWATconstvalue}{DW\-\_AT\-\_const\-\_value}(constant 7)
+        \DWATconstvalue(constant 7)
 \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.
 
-
-
-\paragraph{Duplicate elimination example 2: primary unit }
-\label{app:duplicateeliminationexample2primaryunit}
+\begin{figure}
+\begin{dwflisting}
 \begin{alltt}
-== section .text
+== section \dottext{}
     [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
-            \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)
-            \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)
-            \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}
+\end{dwflisting}
+\caption{Duplicate elimination example \#2: primary unit}
+\label{fig:duplicateeliminationexample2primaryunit}
+\end{figure}
 
 A companion main program is shown in 
-Section \refersec{app:duplicateeliminationexample2companionsource}
-
-\paragraph{Duplicate elimination example 2: companion source }
-\label{app:duplicateeliminationexample2companionsource}
-
-File Main.f 
+Figure \refersec{fig:duplicateeliminationexample2companionsource}
 
-\begin{lstlisting}
+\begin{figure}
+\textit{File Main.f} 
+\begin{nlnlisting}
 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 section group named
-my.f90.company.f90.CommonStuff.fh.654321 
+contained a duplicate of the \addtoindex{section group} named
+\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 
-Section \refersec{app:duplicateeliminationexample2companiondwarf}.
-
-\paragraph{Duplicate elimination example 2: companion DWARF }
-\label{app:duplicateeliminationexample2companiondwarf}
+Figure \refersec{fig:duplicateeliminationexample2companiondwarf}.
 
+\begin{figure}
+\begin{dwflisting}
 \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
-        \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)
-            \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}
+\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 section group
+This example uses \DWTAGpartialunit{} for the \addtoindex{section group}
 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 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 section group are considered before declarations
-from other compilations.}
-
-
 \section{Using Type Units}
 \label{app:usingtypeunits}
 
@@ -698,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 
-addtoindex{.debug\_types} section
+\COMDAT{} \dotdebuginfo{} section
 and arranging for the linker to recognize and eliminate
 duplicates at the individual type level.
 
@@ -711,468 +762,525 @@ implementation, the relocatable object file may contain one
 of each of these debug sections:
 
 \begin{alltt}
-\addtoindex{.debug\_abbrev}
-\addtoindex{.debug\_info}
-\addtoindex{.debug\_line}
+\dotdebugabbrev{}
+\dotdebuginfo{}
+\dotdebugline{}
 \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
-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 section group (or individual
-section) for any given key. For 
-\addtoindex{.debug\_types} sections, the
-key is the type signature formed from the algorithm given in
+will include only one copy of a \addtoindex{section group}
+(or individual section) for any given key. 
+For \COMDAT{} \dotdebuginfo{} sections, the
+key is the \addtoindex{type signature}
+formed from the algorithm given in
 Section \refersec{datarep:typesignaturecomputation}.
 
 \subsection{Signature Computation Example}
 \label{app:signaturecomputationexample}
 
-As an example, consider a \addtoindex{C++} header file 
+As an example, 
+\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 {
 
- 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
-information that describes the type “struct C” as shown
+information that describes the type \doublequote{struct C} as shown
 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}
-  \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:
-      \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:
-     \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}
-
-In computing a signature for the type N::C, flatten the type
+\end{dwflisting}
+\caption{Type signature computation \#1: DWARF representation}
+\label{fig:typesignaturecomputation1dwarfrepresentation}
+\end{figure}
+
+\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 
-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}
-// Step 2: 'C' \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace} "N"
+// Step 2: 'C' \DWTAGnamespace "N"
 0x43 0x39 0x4e 0x00
-// Step 3: 'D' \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type}
+// Step 3: 'D' \DWTAGstructuretype
 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
-// 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")
-    // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
+    // Step 3: 'D' \DWTAGmember
     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
-    // 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
-    // Step 6: 'T' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#2)
+    // Step 6: 'T' \DWATtype (type \#2)
     0x54 0x49
-        // Step 3: 'D' \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}
+        // Step 3: 'D' \DWTAGbasetype
         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
-        // 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
-        // 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
-        // Step 7: End of \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type} "int"
+        // Step 7: End of \DWTAGbasetype "int"
         0x00
-    // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "x"
+    // Step 7: End of \DWTAGmember "x"
     0x00
 // Step 7: Second child ("y")
-    // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
+    // Step 3: 'D' \DWTAGmember
     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
-    // Step 6: 'R' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#2)
+    // Step 6: 'R' \DWATtype (type \#2)
     0x52 0x49 0x02
-    // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "y"
+    // Step 7: End of \DWTAGmember "y"
     0x00
-// Step 7: End of \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type} "C"
+// Step 7: End of \DWTAGstructuretype "C"
 0x00
 \end{alltt}
+\end{dwflisting}
+\caption{Type signature computation \#1: flattened byte stream}
+\label{fig:typesignaturecomputation1flattenedbytestream}
+\end{figure}
 
-Running an 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
-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}
-  \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:
-        \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:
-    \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:
-    \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type}
-         \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L1
+    \DWTAGpointertype
+         \DWATtype : reference to L1
 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:
-       \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}
-
-In this example, the structure types N::A and N::C have each
-been placed in separate type units.  For N::A, the actual
+\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}
+type units.  For \texttt{N::A}, the actual
 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 type unit, since base types and pointer
+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 type unit. The last pointer type contains a reference
-to an incomplete type N::B, which is also included here as
+separate \addtoindex{type unit}. 
+The last pointer type contains a reference
+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
-to N::C, using 
-\livelink{chap:DWFORMrefsig8}{DW\-\_FORM\-\_ref\-\_sig8} to refer to the 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}
-// Step 2: 'C' \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace} "N"
+// Step 2: 'C' \DWTAGnamespace "N"
 0x43 0x39 0x4e 0x00
-// Step 3: 'D' \livelink{chap:DWTAGclasstype}{DW\-\_TAG\-\_class\-\_type}
+// Step 3: 'D' \DWTAGclasstype
 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
-// 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\_")
-    // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
+    // Step 3: 'D' \DWTAGmember
     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
-    // 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
-    // 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
-    // Step 6: 'T' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#2)
+    // Step 6: 'T' \DWATtype (type \#2)
     0x54 0x49
-        // Step 3: 'D' \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}
+        // Step 3: 'D' \DWTAGbasetype
         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
-        // 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
-        // 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
-        // Step 7: End of \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type} "int"
+        // Step 7: End of \DWTAGbasetype "int"
         0x00
-    // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "v\_"
+    // Step 7: End of \DWTAGmember "v\_"
     0x00
 // Step 7: Second child ("next")
-    // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
+    // Step 3: 'D' \DWTAGmember
     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
-    // 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
-    // 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
-    // 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
-        // Step 3: 'D' \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type}
+        // Step 3: 'D' \DWTAGpointertype
         0x44 0x0f
-        // Step 5: 'N' \livelink{chap:DWATtype}{DW\-\_AT\-\_type}
+        // Step 5: 'N' \DWATtype
         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
-        // Step 7: End of \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type}
+        // Step 7: End of \DWTAGpointertype
         0x00
-    // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "next"
+    // Step 7: End of \DWTAGmember "next"
     0x00
 // Step 7: Third child ("bp")
-    // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
+    // Step 3: 'D' \DWTAGmember
     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
-    // 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
-    // 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
-    // Step 6: 'T' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#4)
+    // Step 6: 'T' \DWATtype (type \#4)
     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
-        // 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
-        // Step 7: End of \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type}
+        // Step 7: End of \DWTAGpointertype
         0x00
-    // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "next"
+    // Step 7: End of \DWTAGmember "next"
     0x00
 // Step 7: Fourth child ("c")
-    // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
+    // Step 3: 'D' \DWTAGmember
     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
-    // 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
-    // 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
-    // Step 6: 'T' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#5)
+    // Step 6: 'T' \DWATtype (type \#5)
     0x54 0x49
-        // Step 2: 'C' \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace} "N"
+        // Step 2: 'C' \DWTAGnamespace "N"
         0x43 0x39 0x4e 0x00
-        // Step 3: 'D' \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type}
+        // Step 3: 'D' \DWTAGstructuretype
         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
-        // 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")
-            // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
+            // Step 3: 'D' \DWTAGmember
             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
-            // 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
-            // Step 6: 'R' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#2)
+            // Step 6: 'R' \DWATtype (type \#2)
             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")
-            // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
+            // Step 3: 'D' \DWTAGmember
             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
-            // 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
-            // Step 6: 'R' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#2)
+            // Step 6: 'R' \DWATtype (type \#2)
             0x52 0x49 0x02
-            // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "y"
+            // Step 7: End of \DWTAGmember "y"
             0x00
-        // Step 7: End of \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type} "C"
+        // Step 7: End of \DWTAGstructuretype "C"
         0x00
-    // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "c"
+    // Step 7: End of \DWTAGmember "c"
     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")
-    // Step 3: 'S' \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram} "v"
+    // Step 3: 'S' \DWTAGsubprogram "v"
     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}
+\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 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.
 
-
 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}
-  \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{dwflisting}
+\caption{Type signature example usage}
+\label{fig:typesignatureexampleusage}
+\end{figure}
 
 \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
-during the type signature computation algorithm of Section
+during the type signature computation algorithm of
 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
-
-opt-context           // Step 2
+opt-context               // Step 2
     : 'C' tag-code string opt-context
     : empty
-
-debug-entry           // Step 3
+debug-entry               // Step 3
     : 'D' tag-code
-
-attributes            // Steps 4, 5, 6
+attributes                // Steps 4, 5, 6
     : attribute attributes
     : empty
-
 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
-children             //  Step 7
+children                 //  Step 7
     : child children
-    : '\\0'
-
+    : '\textbackslash{}0'
 child
     : 'S' tag-code string
     : signature
@@ -1181,23 +1289,22 @@ tag-code
 at-code
     : <ULEB128>
 form-encoded-value
-    : \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} value
-    : \livelink{chap:DWFORMflag}{DW\-\_FORM\-\_flag} value
-    : \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} string
-    : \livelink{chap:DWFORMblock}{DW\-\_FORM\-\_block} \nolink{block}
-\livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string}
-    : '\\x08'
-\livelink{chap:DWFORMblock}{DW\-\_FORM\-\_block}
-    : '\\x09'
-\livelink{chap:DWFORMflag}{DW\-\_FORM\-\_flag}
-    : '\\x0c'
-\livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata}
-    : '\\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}
-    : <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
@@ -1205,8 +1312,70 @@ string
 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}
@@ -1221,13 +1390,15 @@ there is substantial header file information
 duplication.
 
 A reasonable approach is to put each header file in its own
-section group, using the naming rules mentioned above. The
+\addtoindex{section group}, using the naming rules mentioned above. The
 section groups are marked to ensure duplicate removal.
 
 All data instances and code instances (even if they came
-from the header files above) are put into non-section group
+from the header files above) are put 
+\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}
@@ -1235,31 +1406,27 @@ sections such as the base object file
 
 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.
 
+\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
-else. The section groups are marked to ensure duplicate
+else. 
+The 
+\addtoindexx{section group}
+section groups are marked to ensure duplicate
 removal, so that the second and subsequent definitions seen
 by the static linker are simply discarded.
 
 
 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}
@@ -1268,7 +1435,9 @@ as a
 Section groups can help make it easy for a linker to completely
 remove unused functions.
 
-Such section groups are not marked for duplicate removal,
+Such 
+\addtoindexx{section group}
+section groups are not marked for duplicate removal,
 since the functions are not duplicates of anything.
 
 Each function is given a compilation unit and a section
@@ -1277,13 +1446,15 @@ 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
-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 section groups here are either deleted
+file sections, as the 
+\addtoindexx{section group}
+section groups here are either deleted
 as unused or kept. There is no possibility (aside from error)
 of a group from some other compilation being used in place
 of one of these groups.
@@ -1296,7 +1467,10 @@ Abstract instances
 \addtoindexx{abstract instance}
 \addtoindexx{concrete out-of-line instance}
 and concrete-out-of-line instances may be
-put in distinct compilation units using section groups. This
+put in distinct compilation units using 
+\addtoindexx{section group}
+section groups. 
+This
 makes possible some useful duplicate DWARF elimination.
 
 \textit{No special provision for eliminating class duplication
@@ -1309,6 +1483,7 @@ groups.}
 \label{app:separatetypeunits}
 
 Each complete declaration of a globally-visible type can be
+\addtoindexx{type unit}
 placed in its own separate type section, with a group key
 derived from the type signature. The linker can then remove
 all duplicate type declarations based on the key.