Change many figures to tables, lots of other fixes
[dwarf-doc.git] / dwarf5 / latexdoc / examples.tex
index 3f3d445..5786a39 100644 (file)
@@ -24,11 +24,11 @@ where possible.
 The figure corresponds to the following two trivial source files:
 
 File myfile.c
-\begin{lstlisting}
+\begin{lstlisting}[numbers=none]
 typedef char* POINTER;
 \end{lstlisting}
 File myfile2.c
-\begin{lstlisting}
+\begin{lstlisting}[numbers=none]
 typedef char* strp;
 \end{lstlisting}
 
@@ -38,7 +38,7 @@ typedef char* strp;
 %\centering
 \begin{minipage}{0.4\textwidth}
 \centering
-Compilation Unit 1: \addtoindex{.debug\_info}
+Compilation Unit \#1: \addtoindex{.debug\_info}
 \begin{framed}
 \scriptsize
 \begin{alltt}
@@ -79,7 +79,7 @@ e2
 %
 %
 \end{framed}
-Compilation Unit 2: \addtoindex{.debug\_info}
+Compilation Unit \#2: \addtoindex{.debug\_info}
 \begin{framed}
 \scriptsize
 \begin{alltt}
@@ -165,8 +165,9 @@ using DWARF.
 
 \subsection{Fortran 90 Example}
 \label{app:fortran90example}
-Consider the Fortran 90 source fragment in 
-Figure \refersec{fig:fortran90examplesourcefragment}.
+Consider the \addtoindex{Fortran 90} source fragment in 
+\addtoindexx{array type entry!examples}
+Figure \referfol{fig:fortran90examplesourcefragment}.
 
 \begin{figure}[here]
 \begin{lstlisting}
@@ -184,7 +185,10 @@ end do
 \end{figure}
 
 For allocatable and pointer arrays, it is essentially required
-by the Fortran 90 semantics that each array consist of two
+by the \addtoindex{Fortran 90} semantics that each array consist of 
+\addtoindexx{descriptor!array}
+two
+\addtoindexx{array!descriptor for}
 parts, which we here call 1) the descriptor and 2) the raw
 data. (A descriptor has often been called a dope vector in
 other contexts, although it is often a structure of some kind
@@ -202,7 +206,9 @@ Note, however, that it is
 a property of the design that 1) a debugger needs no builtin
 knowledge of this structure and 2) there does not need to
 be an explicit representation of this structure in the DWARF
-input to the debugger.
+input to the 
+\addtoindexx{Fortran 90}
+debugger.
 
 \begin{figure}[here]
 \begin{lstlisting}
@@ -211,7 +217,7 @@ struct desc {
     void * base; // Address of raw data
     int ptr_assoc : 1; // Pointer is associated flag
     int ptr_alloc : 1; // Pointer is allocated flag
-    int num_dims : 6; // Number of dimensions
+    int num_dims  : 6; // Number of dimensions
     struct dims_str { // For each dimension...  
         long low_bound;
         long upper_bound;
@@ -219,22 +225,23 @@ struct desc {
     } dims[63];
 };
 \end{lstlisting}
-\caption{Fortran 90 example: descriptor representation} \label{fig:fortran90exampledescriptorrepresentation}
+\caption{Fortran 90 example: descriptor representation}
+\label{fig:fortran90exampledescriptorrepresentation}
 \end{figure}
 
 
 In practice, of course, a “real” descriptor will have
 dimension substructures only for as many dimensions as are
 specified in the num\_dims component. Let us use the notation
-desc ,textless n \textgreater\   
+\texttt{desc\textless n\textgreater}   
 to indicate a specialization of the desc struct in
-which n is the bound for the dims component as well as the
+which \texttt{n} is the bound for the dims component as well as the
 contents of the num\_dims component.
 
 Because the arrays considered here come in two parts, it is
 necessary to distinguish the parts carefully. In particular,
 the “address of the variable” or equivalently, the “base
-address of the object” always refers to the descriptor. For
+address of the object” \emph{always} refers to the descriptor. For
 arrays that do not come in two parts, an implementation can
 provide a descriptor anyway, thereby giving it two parts. (This
 may be convenient for general runtime support unrelated to
@@ -247,19 +254,21 @@ that can be the object).
 
 If an object has a descriptor, then the DWARF type for that
 object will have a 
-\livelink{chap:DWATdatalocation}{DW\-\_AT\-\_data\-\_location} attribute. If an object
+\livelink{chap:DWATdatalocation}{DW\-\_AT\-\_data\-\_location} 
+attribute. If an object
 does not have a descriptor, then usually the DWARF type for the
 object will not have a 
 \livelink{chap:DWATdatalocation}{DW\-\_AT\-\_data\-\_location}. 
 (See the following
 \addtoindex{Ada} example for a case where the type for an object without
-a descriptor does have a \livelink{chap:DWATdatalocation}{DW\-\_AT\-\_data\-\_location} attribute. In
+a descriptor does have a 
+\livelink{chap:DWATdatalocation}{DW\-\_AT\-\_data\-\_location} attribute. In
 that case the object doubles as its own descriptor.)
 
-The Fortran 90 derived type array\_ptr can now be redescribed
+The \addtoindex{Fortran 90} derived type array\_ptr can now be redescribed
 in C\dash like terms that expose some of the representation as in
 
-\begin{lstlisting}
+\begin{lstlisting}[numbers=none]
 struct array_ptr {
     float myvar;
     desc<1> ap;
@@ -267,32 +276,30 @@ struct array_ptr {
 \end{lstlisting}
 
 Similarly for variable arrays:
-\begin{lstlisting}
+\begin{lstlisting}[numbers=none]
 desc<1> arrays;
 \end{lstlisting}
 
-(Recall that desc \textless 1 \textgreater 
-indicates the 1\dash dimensional version of desc.)
+(Recall that \texttt{desc\textless 1\textgreater} 
+indicates the 1\dash dimensional version of \texttt{desc}.)
 
+\newpage
 Finally, the following notation is useful:
-
 \begin{enumerate}[1.]
 \item  sizeof(type): size in bytes of entities of the given type
-
 \item offset(type, comp): offset in bytes of the comp component
 within an entity of the given type
 \end{enumerate}
 
+The DWARF description is shown 
+\addtoindexx{Fortran 90}
+in Figure \refersec{fig:fortran90exampledwarfdescription}.
 
-The DWARF description is shown in 
-Section \refersec{app:fortran90exampledwarfdescription}.
-
-\subsection{Fortran 90 example: DWARF description}
-\label{app:fortran90exampledwarfdescription}
-
+\begin{figure}[b]
+\begin{dwflisting}
 \begin{alltt}
 ! Description for type of 'ap'
-
+!
 1\$: \livelink{chap:DWTAGarraytype}{DW\-\_TAG\-\_array\-\_type}
         ! No name, default (Fortran) ordering, default stride
         \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to REAL)
@@ -308,11 +315,20 @@ Section \refersec{app:fortran90exampledwarfdescription}.
             \livelink{chap:DWOPlit}{DW\-\_OP\-\_lit}<n> ! where n == offset(base)
             \livelink{chap:DWOPplus}{DW\-\_OP\-\_plus}
             \livelink{chap:DWOPderef}{DW\-\_OP\-\_deref}) ! Type of index of array 'ap'
-2\$:     \livelink{chap:DWTAGsubrangetype}{DW\-\_TAG\-\_subrange\-\_type}
+\end{alltt}
+\end{dwflisting}
+\caption{Fortran 90 example: DWARF description}
+\label{fig:fortran90exampledwarfdescription}
+\end{figure}
+
+\begin{figure}
+\begin{dwflisting}
+\begin{alltt}
+2\$: \livelink{chap:DWTAGsubrangetype}{DW\-\_TAG\-\_subrange\-\_type}
         ! No name, default stride
         \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to INTEGER)
         \livelink{chap:DWATlowerbound}{DW\-\_AT\-\_lower\-\_bound}(expression=
-        \livelink{chap:DWOPpushobjectaddress}{DW\-\_OP\-\_push\-\_object\-\_address}
+            \livelink{chap:DWOPpushobjectaddress}{DW\-\_OP\-\_push\-\_object\-\_address}
             \livelink{chap:DWOPlit}{DW\-\_OP\-\_lit}<n> ! where n ==
                          !  offset(desc, dims) +
                          !  offset(dims\_str, lower\_bound)
@@ -327,12 +343,11 @@ Section \refersec{app:fortran90exampledwarfdescription}.
             \livelink{chap:DWOPderef}{DW\-\_OP\-\_deref})
         !  Note: for the m'th dimension, the second operator becomes
         !  \livelink{chap:DWOPlit}{DW\-\_OP\-\_lit}<x> where
-        !  x == offset(desc, dims) +
-        !  (m-1)*sizeof(dims\_str) +
-        !  offset(dims\_str, [lower|upper]\_bound)
-        !  That is, the expression does not get longer for each
-        !  successive dimension (other than to express the larger
-        !  offsets involved).
+        !       x == offset(desc, dims)         +
+        !                (m-1)*sizeof(dims\_str) +
+        !                 offset(dims\_str, [lower|upper]\_bound)
+        !  That is, the expression does not get longer for each successive 
+        !  dimension (other than to express the larger offsets involved).
 3\$: \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type}
         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("array\_ptr")
         \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size}(constant sizeof(REAL) + sizeof(desc<1>))
@@ -344,19 +359,28 @@ Section \refersec{app:fortran90exampledwarfdescription}.
             \livelink{chap:DWATname}{DW\-\_AT\-\_name}("ap");
             \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 1\$)
             \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location}(constant sizeof(REAL))
-
 6\$: \livelink{chap:DWTAGarraytype}{DW\-\_TAG\-\_array\-\_type}
         ! No name, default (Fortran) ordering, default stride
         \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 3\$)
         \livelink{chap:DWATallocated}{DW\-\_AT\-\_allocated}(expression=
-             ! Test 'ptr\_alloc' \nolink{flag}
+            ! Test 'ptr\_alloc' \nolink{flag}
             \livelink{chap:DWOPpushobjectaddress}{DW\-\_OP\-\_push\-\_object\-\_address}
             \livelink{chap:DWOPlit}{DW\-\_OP\-\_lit}<n> ! where n == offset(ptr\_alloc)
             \livelink{chap:DWOPplus}{DW\-\_OP\-\_plus}
             \livelink{chap:DWOPderef}{DW\-\_OP\-\_deref}
             \livetarg{chap:DWOPlit2}{DW\-\_OP\-\_lit2}
-             ! mask for 'ptr\_alloc' \nolink{flag}
+            ! Mask for 'ptr\_alloc' \nolink{flag}
             \livelink{chap:DWOPand}{DW\-\_OP\-\_and})
+\end{alltt}
+\end{dwflisting}
+\begin{center}
+Figure~\ref{fig:fortran90exampledwarfdescription} Fortran 90 example: DWARF description \textit{(continued)}
+\end{center}
+\end{figure}
+
+\begin{figure}
+\begin{dwflisting}
+\begin{alltt}
         \livelink{chap:DWATdatalocation}{DW\-\_AT\-\_data\-\_location}(expression= ! Get raw data address
             \livelink{chap:DWOPpushobjectaddress}{DW\-\_OP\-\_push\-\_object\-\_address}
             \livelink{chap:DWOPlit}{DW\-\_OP\-\_lit}<n> ! where n = offset(base)
@@ -383,15 +407,20 @@ Section \refersec{app:fortran90exampledwarfdescription}.
         \livelink{chap:DWATlocation}{DW\-\_AT\-\_location}(expression=
             ...as appropriate...) ! Assume static allocation
 \end{alltt}
+\end{dwflisting}
+\begin{center}
 
-\subsection{Fortran 90 example continued: DWARF description}
-\label{app:fortran90examplecontinueddwarfdescription}
+Figure~\ref{fig:fortran90exampledwarfdescription} Fortran 90 example: DWARF description \textit{(concluded)}
+\end{center}
+\end{figure}
 
-Suppose the program is stopped immediately following completion
+Suppose 
+\addtoindexx{Fortran 90 example}
+the program is stopped immediately following completion
 of the do loop. Suppose further that the user enters the
 following debug command:
 
-\begin{lstlisting}
+\begin{lstlisting}[numbers=none]
 debug> print arrays(5)%ap(2)
 \end{lstlisting}
 
@@ -404,10 +433,10 @@ whose type is given by the unnamed type at 6\$. Notice that
 the type is an array type.
 
 
-\item Find the 5 element of that array object. To do array
+\item Find the 5$^{th}$ element of that array object. To do array
 indexing requires several pieces of information:
 
-\begin{enumerate}[a]
+\begin{enumerate}[a)]
 
 \item  the address of the array data
 
@@ -460,7 +489,7 @@ symbol table.
 \item  Find the second element of the array object found in step 3. To do array indexing requires
 several pieces of information:
 
-\begin{enumerate}[a]
+\begin{enumerate}[a)]
 \item  the address of the array storage
 
 \item  the lower bounds of the array \\
@@ -483,7 +512,7 @@ Note: we happen to be accessing a pointer array here instead
 of an allocatable array; but because there is a common
 underlying representation, the mechanics are the same. There
 could be completely different descriptor arrangements and the
-mechanics would still be the same — only the stack machines
+mechanics would still be the same---only the stack machines
 would be different.
 
 
@@ -491,7 +520,7 @@ would be different.
 \subsection{Ada Example}
 \label{app:adaexample}
 
-Figure \refersec{fig:adaexamplesourcefragment}
+Figure \referfol{fig:adaexamplesourcefragment}
 illustrates two kinds of \addtoindex{Ada} 
 parameterized array, one embedded in a record.
 
@@ -508,7 +537,8 @@ end record;
 
 OBJ2B : REC2;
 \end{lstlisting}
-\caption{Ada 90 example: source fragment} \label{fig:adaexamplesourcefragment}
+\caption{Ada 90 example: source fragment}
+\label{fig:adaexamplesourcefragment}
 \end{figure}
 
 VEC1 illustrates an (unnamed) array type where the upper bound
@@ -532,7 +562,7 @@ because that value is potentially used in the specification
 of other components of the record.)
 
 The DWARF description is shown in 
-Section \refersec{app:adaexampledwarfdescription}
+Figure \refersec{fig:adaexampledwarfdescription}.
 
 
 Interesting aspects about this example are:
@@ -560,9 +590,8 @@ the unconstrained array ARR is not needed for the purposes
 of this example and therefore not shown.
 \end{enumerate}
 
-\subsubsection{Ada example: DWARF description}
-\label{app:adaexampledwarfdescription}
-
+\begin{figure}[p]
+\begin{dwflisting}
 \begin{alltt}
 11\$: \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable}
         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("M")
@@ -587,7 +616,7 @@ of this example and therefore not shown.
       . . .
 26\$: \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type}
         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("REC2")
-27\$:   \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
+27\$:    \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
             \livelink{chap:DWATname}{DW\-\_AT\-\_name}("N")
             \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to subtype TEENY at 21\$)
             \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location}(constant 0)
@@ -595,7 +624,7 @@ of this example and therefore not shown.
             ! No name, default (\addtoindex{Ada}) order, default stride
             ! Default data location
             \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to INTEGER)
-29\$:       \livelink{chap:DWTAGsubrangetype}{DW\-\_TAG\-\_subrange\-\_type}
+29\$:        \livelink{chap:DWTAGsubrangetype}{DW\-\_TAG\-\_subrange\-\_type}
                 \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to subrange TEENY at 21\$)
                 \livelink{chap:DWATlowerbound}{DW\-\_AT\-\_lower\-\_bound}(constant 1)
                 \livelink{chap:DWATupperbound}{DW\-\_AT\-\_upper\-\_bound}(reference to member N at 27\$)
@@ -610,38 +639,42 @@ of this example and therefore not shown.
         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("OBJ2B")
         \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to REC2 at 26\$)
         \livelink{chap:DWATlocation}{DW\-\_AT\-\_location}(...as appropriate...)
-
 \end{alltt}
+\end{dwflisting}
+\caption{Ada 90 example: DWARF description}
+\label{fig:adaexampledwarfdescription}
+\end{figure}
 
 \subsection{Pascal Example}
 \label{app:pascalexample}
 
-The Pascal source in 
-Figure \refersec{fig:packedrecordexamplesourcefragment}
-is used to illustrate the representation of packed unaligned bit
-fields.
+The Pascal \addtoindexx{Pascal example} source in 
+Figure \referfol{fig:packedrecordexamplesourcefragment}
+is used to illustrate the representation of packed unaligned
+\addtoindex{bit fields}.
+
 \begin{figure}[here]
 \begin{lstlisting}
-TYPE T : PACKED RECORD ! bit size is 2
-F5 : BOOLEAN; ! bit offset is 0
-F6 : BOOLEAN; ! bit offset is 1
-END;
-VAR V : PACKED RECORD
-F1 : BOOLEAN; ! bit offset is 0
-F2 : PACKED RECORD ! bit offset is 1
-F3 : INTEGER; ! bit offset is 0 in F2, 1 in V
-END;
-F4 : PACKED ARRAY [0..1] OF T; ! bit offset is 33
-F7 : T; ! bit offset is 37
+TYPE T : PACKED RECORD                  ! bit size is 2
+         F5 : BOOLEAN;                  ! bit offset is 0
+         F6 : BOOLEAN;                  ! bit offset is 1
+         END;
+VAR V  : PACKED RECORD
+         F1 : BOOLEAN;                  ! bit offset is 0
+         F2 : PACKED RECORD             ! bit offset is 1
+              F3 : INTEGER;             ! bit offset is 0 in F2, 1 in V
+              END;
+         F4 : PACKED ARRAY [0..1] OF T; ! bit offset is 33
+         F7 : T;                        ! bit offset is 37
 END;
 \end{lstlisting}
-\caption{Packed record example: source fragment} \label{fig:packedrecordexamplesourcefragment}
+\caption{Packed record example: source fragment}
+\label{fig:packedrecordexamplesourcefragment}
 \end{figure}
 
 The DWARF representation in 
-Section \refersec{app:packedrecordexampledwarfdescription} 
-is
-appropriate. 
+Figure \refersec{fig:packedrecordexampledwarfdescription} 
+is appropriate. 
 \livelink{chap:DWTAGpackedtype}{DW\-\_TAG\-\_packed\-\_type} entries could be added to
 better represent the source, but these do not otherwise affect
 the example and are omitted for clarity. Note that this same
@@ -651,8 +684,8 @@ architectures using the conventions described in
 Section \refersec{chap:datamemberentries}.
 
 
-\subsection{Packed record example: DWARF description}
-\label{app:packedrecordexampledwarfdescription}
+\begin{figure}[p]
+\begin{dwflisting}
 % DWARF4 had some entries here as \livelink{chap:DWATmember}{DW_AT_member} .
 % Those are fixed here to \livelink{chap:DWTAGmember}{DW_TAG_member}
 \begin{alltt}
@@ -668,9 +701,9 @@ Section \refersec{chap:datamemberentries}.
             \livelink{chap:DWATlowerbound}{DW\-\_AT\-\_lower\-\_bound}(0)
             \livelink{chap:DWATupperbound}{DW\-\_AT\-\_upper\-\_bound}(1)
         \livelink{chap:DWATbitstride}{DW\-\_AT\-\_bit\-\_stride}(2)
-        \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size}(4)
+        \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size}(4) \addtoindexx{bit size attribute}
 23\$: \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type} ! anonymous type for V
-        \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size}(39)
+        \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size}(39) \addtoindexx{bit size attribute}
         \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
             \livelink{chap:DWATname}{DW\-\_AT\-\_name}("F1")
             \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 10\$)
@@ -690,23 +723,31 @@ Section \refersec{chap:datamemberentries}.
             \livelink{chap:DWATname}{DW\-\_AT\-\_name}("F7")
             \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 20\$) ! type T
             \livelink{chap:DWATdatabitoffset}{DW\-\_AT\-\_data\-\_bit\-\_offset}(37)
-            \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size}(2) ! may be omitted
+            \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size}(2) \addtoindexx{bit size attribute}! may be omitted
      \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable}
         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("V")
         \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 23\$)
         \livelink{chap:DWATlocation}{DW\-\_AT\-\_location}(...)
         ...
 \end{alltt}
+\end{dwflisting}
+\caption{Packed record example: DWARF description}
+\label{fig:packedrecordexampledwarfdescription}
+\end{figure}
 
 \section{Namespace Example}
 \label{app:namespaceexample}
 
-
-The C++ example in 
+The \addtoindex{C++} example in 
 Figure \refersec{fig:namespaceexamplesourcefragment}
-is used to illustrate the representation of namespaces.
+is used 
+\addtoindexx{namespace (C++)!example}
+to illustrate the representation of namespaces.
+The DWARF representation in 
+Figure \refersec{fig:namespaceexampledwarfdescription}
+is appropriate.
 
-\begin{figure}[here]
+\begin{figure}[p]
 \begin{lstlisting}
 namespace {
     int i;
@@ -742,16 +783,13 @@ int Foo::myfunc(int a)
     return myfunc2(3) + j + i + a + 2;
 }
 \end{lstlisting}
-\caption{Namespace example: source fragment} \label{fig:namespaceexamplesourcefragment}
+\caption{Namespace example: source fragment}
+\label{fig:namespaceexamplesourcefragment}
 \end{figure}
 
 
-The DWARF representation in 
-Section \refersec{app:namespaceexampledwarfdescription}
-is appropriate.
-
-\subsection{Namespace example: DWARF description}
-\label{app:namespaceexampledwarfdescription}
+\begin{figure}[p]
+\begin{dwflisting}
 \begin{alltt}
 
 1\$:  \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}
@@ -791,7 +829,15 @@ is appropriate.
                 \livelink{chap:DWAThighpc}{DW\-\_AT\-\_high\-\_pc} ...
                 \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 1\$)
                 ...
+\end{alltt}
+\end{dwflisting}
+\caption{Namespace example: DWARF description}
+\label{fig:namespaceexampledwarfdescription}
+\end{figure}
 
+\begin{figure}
+\begin{dwflisting}
+\begin{alltt}
 40\$: \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace}
         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("Y")
         \livelink{chap:DWTAGimporteddeclaration}{DW\-\_TAG\-\_imported\-\_declaration}    ! (1) using-declaration
@@ -829,6 +875,11 @@ is appropriate.
         \livelink{chap:DWAThighpc}{DW\-\_AT\-\_high\-\_pc} ...
         ...
 \end{alltt}
+\end{dwflisting}
+\begin{center}
+Figure~\ref{fig:namespaceexampledwarfdescription}: Namespace example: DWARF description \textit{(concluded)}
+\end{center}
+\end{figure}
 
 \section{Member Function Example}
 \label{app:memberfunctionexample}
@@ -836,7 +887,7 @@ is appropriate.
 Consider the member function example fragment in 
 Figure \refersec{fig:memberfunctionexamplesourcefragment}.
 
-\begin{figure}[here]
+\begin{figure}[Here]
 \begin{lstlisting}
 class A
 {
@@ -846,19 +897,16 @@ class A
 };
 void A::func1(int x) {}
 \end{lstlisting}
-\caption{Member function example: source fragment} \label{fig:memberfunctionexamplesourcefragment}
+\caption{Member function example: source fragment}
+\label{fig:memberfunctionexamplesourcefragment}
 \end{figure}
 
-
-
 The DWARF representation in 
-Section \refersec{app:memberfunctionexampledwarfdescription}
+Section \refersec{fig:memberfunctionexampledwarfdescription}
 is appropriate.
 
-\subsection{Member function example: DWARF description}
-\label{app:memberfunctionexampledwarfdescription}
-
-
+\begin{figure}[h]
+\begin{dwflisting}
 \begin{alltt}
 1\$: \livelink{chap:DWTAGunspecifiedtype}{DW\-\_TAG\-\_unspecified\-\_type}
         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("void")
@@ -883,10 +931,19 @@ is appropriate.
             \livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration}
             \livelink{chap:DWATname}{DW\-\_AT\-\_name}("func1")
             \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 1\$)
-            \livelink{chap:DWATobjectpointer}{DW\-\_AT\-\_object\-\_pointer}(reference to 8\$)
+            \livelink{chap:DWATobjectpointer}{DW\-\_AT\-\_object\-\_pointer}(reference to 8\$) \addtoindexx{object pointer attribute}
                 ! References a formal parameter in this 
                 ! member function
             ...
+\end{alltt}
+\end{dwflisting}
+\caption{Member function example: DWARF description}
+\label{fig:memberfunctionexampledwarfdescription}
+\end{figure}
+
+\begin{figure}[p]
+\begin{dwflisting}
+\begin{alltt}
 8\$:        \livelink{chap:DWTAGformalparameter}{DW\-\_TAG\-\_formal\-\_parameter}
                 \livelink{chap:DWATartificial}{DW\-\_AT\-\_artificial}(true)
                 \livelink{chap:DWATname}{DW\-\_AT\-\_name}("this")
@@ -904,7 +961,7 @@ is appropriate.
              \livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration}
              \livelink{chap:DWATname}{DW\-\_AT\-\_name}("func2")
              \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 1\$)
-             \livelink{chap:DWATobjectpointer}{DW\-\_AT\-\_object\-\_pointer}(reference to 11\$)
+             \livelink{chap:DWATobjectpointer}{DW\-\_AT\-\_object\-\_pointer}(reference to 11\$) \addtoindexx{object pointer attribute}
              ! References a formal parameter in this 
              ! member function
              ...
@@ -928,7 +985,13 @@ is appropriate.
                  \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 2\$)
                  ...
 \end{alltt}
+\end{dwflisting}
+\begin{center}
+Figure~\ref{fig:memberfunctionexampledwarfdescription}: Member function example: DWARF description \textit{(concluded)}
+\end{center}
+\end{figure}
 
+\clearpage
 \section{Line Number Program Example}
 \label{app:linenumberprogramexample}
 
@@ -958,35 +1021,42 @@ Figure \refersec{fig:linenumberprogramexamplemachinecode}.
     0x24c: ret
 7: 0x24d:
 \end{lstlisting}
-\caption{Line number program example: machine code} \label{fig:linenumberprogramexamplemachinecode}
+\caption{Line number program example: machine code}
+\label{fig:linenumberprogramexamplemachinecode}
 \end{figure}
 
 Suppose the line number program header includes the following
-(header fields not needed below are not shown):
-
-
-
+(header fields not needed 
+\addtoindexx{line\_base}
+below 
+\addtoindexx{line\_range}
+are 
+\addtoindexx{opcode\_base}
+not 
+\addtoindexx{minumum\_instruction\_length}
+shown):
 \begin{alltt}
-version                    4
-minimum_instruction_length 1
-opcode_base               10 ! Opcodes 10-12 not needed
-line_base                  1
-line_range                15
+    version                       4
+    minimum_instruction_length    1
+    opcode_base                  10   ! Opcodes 10-12 not needed
+    line_base                     1
+    line_range                   15
 \end{alltt}
 
 
-Figure \refersec{tab:linenumberprogramexampleoneencoding}
+Table \refersec{tab:linenumberprogramexampleoneencoding}
 shows one encoding of the line number program, which occupies
 12 bytes (the opcode SPECIAL(m,n) indicates the special opcode
 generated for a line increment of m and an address increment
 of n).
 
-
+\newpage
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \begin{longtable}{lll}
-  \caption{Line number program example: one encoding} \label{tab:linenumberprogramexampleoneencoding} \\
-  \hline \\ \bfseries Opcode &\bfseries Operand &\bfseries Byte Stream \\ \hline
+  \caption{Line number program example: one encoding}
+  \label{tab:linenumberprogramexampleoneencoding} \\
+  \hline \bfseries Opcode &\bfseries Operand &\bfseries Byte Stream \\ \hline
 \endfirsthead
   \bfseries Opcode &\bfseries Operand &\bfseries Byte Stream\\ \hline
 \endhead
@@ -1015,8 +1085,9 @@ this encoding occupies 22 bytes.
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \begin{longtable}{lll}
-  \caption{Line number program example: alternate encoding} \label{tab:linenumberprogramexamplealternateencoding} \\
-  \hline \\ \bfseries Opcode &\bfseries Operand &\bfseries Byte Stream \\ \hline
+  \caption{Line number program example: alternate encoding} 
+  \label{tab:linenumberprogramexamplealternateencoding} \\
+  \hline \bfseries Opcode &\bfseries Operand &\bfseries Byte Stream \\ \hline
 \endfirsthead
   \bfseries Opcode &\bfseries Operand &\bfseries Byte Stream\\ \hline
 \endhead
@@ -1043,16 +1114,14 @@ SPECIAL(1, 0) && 0xa        \\
 
 The following example uses a hypothetical RISC machine in
 the style of the Motorola 88000.
-
 \begin{itemize}
 \item Memory is byte addressed.
 
 \item Instructions are all 4 bytes each and word aligned.
 
 \item Instruction operands are typically of the form:
-
 \begin{alltt}
-<destination.reg>, <source.reg>, <constant>
+    <destination.reg>, <source.reg>, <constant>
 \end{alltt}
 
 \item The address for the load and store instructions is computed
@@ -1060,13 +1129,12 @@ by adding the contents of the
 source register with the constant.
 
 \item There are 8 4\dash byte registers:
-
 \begin{alltt}
-R0 always 0
-R1 holds return address on call
-R2-R3 temp registers (not preserved on call)
-R4-R6 preserved on call
-R7 stack pointer.
+    R0 always 0
+    R1 holds return address on call
+    R2-R3 temp registers (not preserved on call)
+    R4-R6 preserved on call
+    R7 stack pointer.
 \end{alltt}
 
 \item  The stack grows in the negative direction.
@@ -1076,13 +1144,12 @@ stack pointer (R7) is the same as the CFA
 
 \end{itemize}
 
-The following 
-(Figure refersec{fig:callframeinformationexamplemachinecodefragments}
-are two code fragments from a subroutine called
+Figure \referfol{fig:callframeinformationexamplemachinecodefragments}
+shows two code fragments from a subroutine called
 foo that uses a frame pointer (in addition to the stack
 pointer). The first column values are byte addresses. 
 % The \space is so we get a space after >
-\textless~fs~\textgreater \  denotes the stack frame size in bytes, namely 12.
+\textless fs\textgreater\ denotes the stack frame size in bytes, namely 12.
 
 
 \begin{figure}[here]
@@ -1103,15 +1170,15 @@ foo+76 add R7, R7, <fs>        ; Deallocate frame
 foo+80 jump R1 ; Return
 foo+84
 \end{lstlisting}
-\caption{Call frame information example: machine code fragments} \label{fig:callframeinformationexamplemachinecodefragments}
+\caption{Call frame information example: machine code fragments}
+\label{fig:callframeinformationexamplemachinecodefragments}
 \end{figure}
 
 
 An abstract table 
 (see Section \refersec{chap:structureofcallframeinformation}) 
-for the foo subroutine
-is shown in 
-Table \refersec{tab:callframeinformationexampleconceptualmatrix}.
+for the foo subroutine is shown in 
+Table \referfol{tab:callframeinformationexampleconceptualmatrix}.
 Corresponding fragments from the
 \addtoindex{.debug\_frame} section are shown in 
 Table \refersec{tab:callframeinformationexamplecommoninformationentryencoding}.
@@ -1131,8 +1198,9 @@ Table \refersec{tab:callframeinformationexampleconceptualmatrix}:
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \begin{longtable}{lllllllllll}
-  \caption{Call frame inforation example: conceptual matrix} \label{tab:callframeinformationexampleconceptualmatrix} \\
-  \hline \\ \bfseries Location & \bfseries CFA & \bfseries R0 & \bfseries R1 & \bfseries R2 & \bfseries R3 & \bfseries R4 & \bfseries R5 & \bfseries R6 & \bfseries R7 & \bfseries R8 \\ \hline
+  \caption{Call frame information example: conceptual matrix} 
+  \label{tab:callframeinformationexampleconceptualmatrix} \\
+  \hline \bfseries Location & \bfseries CFA & \bfseries R0 & \bfseries R1 & \bfseries R2 & \bfseries R3 & \bfseries R4 & \bfseries R5 & \bfseries R6 & \bfseries R7 & \bfseries R8 \\ \hline
 \endfirsthead
   \bfseries Location &\bfseries CFA &\bfseries R0 & \bfseries R1 & \bfseries R2 &\bfseries R3 &\bfseries R4 &\bfseries R5 &\bfseries R6 &\bfseries R7 &\bfseries R8\\ \hline
 \endhead
@@ -1159,8 +1227,9 @@ foo+80&[R7]+0&s&u&u&u&s&s&s&a&r1 \\
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \begin{longtable}{lll}
-  \caption{Call frame information example: common information entry encoding} \label{tab:callframeinformationexamplecommoninformationentryencoding} \\
-  \hline \\ \bfseries Address &\bfseries Value &\bfseries Comment \\ \hline
+  \caption{Call frame information example: common information entry encoding} 
+  \label{tab:callframeinformationexamplecommoninformationentryencoding} \\
+  \hline \bfseries Address &\bfseries Value &\bfseries Comment \\ \hline
 \endfirsthead
   \bfseries Address &\bfseries Value &\bfseries Comment \\ \hline
 \endhead
@@ -1187,8 +1256,8 @@ cie+28&\livelink{chap:DWCFAsamevalue}{DW\-\_CFA\-\_same\-\_value} (5)&R5 preserv
 cie+30&\livelink{chap:DWCFAsamevalue}{DW\-\_CFA\-\_same\-\_value} (6)&R6 preserve    \\
 cie+32&\livelink{chap:DWCFAsamevalue}{DW\-\_CFA\-\_same\-\_value} (7)&R7 preserve    \\
 cie+34&\livelink{chap:DWCFAregister}{DW\-\_CFA\-\_register} (8, 1)&R8 is in R1    \\
-cie+37&\livelink{chap:DWCFAnop}{DW\-\_CFA\-\_nop}&padding    \\
-cie+38&\livelink{chap:DWCFAnop}{DW\-\_CFA\-\_nop}padding \\
+cie+37&\livelink{chap:DWCFAnop}{DW\-\_CFA\-\_nop} &padding    \\
+cie+38&\livelink{chap:DWCFAnop}{DW\-\_CFA\-\_nop} &padding \\
 cie+39& \livelink{chap:DWCFAnop}{DW\-\_CFA\-\_nop}&padding  \\
 cie+40 &&  \\
 \end{longtable}
@@ -1199,7 +1268,7 @@ The following notations apply in
 Table \refersec{tab:callframeinformationexampleframedescriptionentryencoding}:
 
 \begin{alltt}
-1. <fs> = frame size
+1. <fs>  = frame size
 2. <caf> = code alignment factor
 3. <daf> = data alignment factor
 \end{alltt}
@@ -1208,8 +1277,9 @@ Table \refersec{tab:callframeinformationexampleframedescriptionentryencoding}:
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \begin{longtable}{lll}
-  \caption{Call frame information example: frame description entry encoding} \label{tab:callframeinformationexampleframedescriptionentryencoding} \\
-  \hline \\ \bfseries Address &\bfseries Value &\bfseries Comment \\ \hline
+  \caption{Call frame information example: frame description entry encoding} 
+  \label{tab:callframeinformationexampleframedescriptionentryencoding} \\
+  \hline \bfseries Address &\bfseries Value &\bfseries Comment \\ \hline
 \endfirsthead
   \bfseries Address &\bfseries Value &\bfseries Comment \\ \hline
 \endhead
@@ -1222,16 +1292,16 @@ fde+4&cie&CIE\_ptr \\
 fde+8&foo&initial\_location \\
 fde+12&84&address\_range \\
 fde+16&\livelink{chap:DWCFAadvanceloc}{DW\-\_CFA\-\_advance\-\_loc}(1)&instructions \\
-fde+17&\livelink{chap:DWCFAdefcfaoffset}{DW\-\_CFA\-\_def\-\_cfa\-\_offset}(12)& \textless fs \textgreater \\
-fde+19&\livelink{chap:DWCFAadvanceloc}{DW\-\_CFA\-\_advance\-\_loc}(1)&4/ \textless caf \textgreater \\
-fde+20&\livelink{chap:DWCFAoffset}{DW\-\_CFA\-\_offset}(8,1)&-4/ \textless daf \textgreater (second parameter) \\
+fde+17&\livelink{chap:DWCFAdefcfaoffset}{DW\-\_CFA\-\_def\-\_cfa\-\_offset}(12)& \textless fs\textgreater \\
+fde+19&\livelink{chap:DWCFAadvanceloc}{DW\-\_CFA\-\_advance\-\_loc}(1)&4/ \textless caf\textgreater \\
+fde+20&\livelink{chap:DWCFAoffset}{DW\-\_CFA\-\_offset}(8,1)&-4/ \textless daf\textgreater (2nd parameter) \\
 fde+22&\livelink{chap:DWCFAadvanceloc}{DW\-\_CFA\-\_advance\-\_loc}(1)& \\
-fde+23&\livelink{chap:DWCFAoffset}{DW\-\_CFA\-\_offset}(6,2)&-8/ \textless daf\textgreater (2nd parameter)  \\
+fde+23&\livelink{chap:DWCFAoffset}{DW\-\_CFA\-\_offset}(6,2)&-8/ \textless daf\textgreater (2nd parameter)  \\
 fde+25&\livelink{chap:DWCFAadvanceloc}{DW\-\_CFA\-\_advance\-\_loc}(1) & \\
 fde+26&\livelink{chap:DWCFAdefcfaregister}{DW\-\_CFA\-\_def\-\_cfa\-\_register}(6) & \\
 fde+28&\livelink{chap:DWCFAadvanceloc}{DW\-\_CFA\-\_advance\-\_loc}(1) & \\
-fde+29&\livelink{chap:DWCFAoffset}{DW\-\_CFA\-\_offset}(4,3)&-12/ \textless daf \textgreater (2nd parameter) \\
-fde+31&\livelink{chap:DWCFAadvanceloc}{DW\-\_CFA\-\_advance\-\_loc}(12)&44/ \textless caf \textgreater \\
+fde+29&\livelink{chap:DWCFAoffset}{DW\-\_CFA\-\_offset}(4,3)&-12/ \textless daf\textgreater (2nd parameter) \\
+fde+31&\livelink{chap:DWCFAadvanceloc}{DW\-\_CFA\-\_advance\-\_loc}(12)&44/ \textless caf\textgreater \\
 fde+32&\livelink{chap:DWCFArestore}{DW\-\_CFA\-\_restore}(4)& \\
 fde+33&\livelink{chap:DWCFAadvanceloc}{DW\-\_CFA\-\_advance\-\_loc}(1) & \\
 fde+34&\livelink{chap:DWCFArestore}{DW\-\_CFA\-\_restore}(6) & \\
@@ -1249,8 +1319,9 @@ fde+44 && \\
 \section{Inlining Examples}
 \label{app:inliningexamples}
 The pseudo\dash source in 
-Figure \refersec{fig:inliningexamplespseudosourcefragment}
+Figure \referfol{fig:inliningexamplespseudosourcefragment}
 is used to illustrate the
+\addtoindexx{inlined subprogram call!examples}
 use of DWARF to describe inlined subroutine calls. This
 example involves a nested subprogram INNER that makes uplevel
 references to the formal parameter and local variable of the
@@ -1274,7 +1345,8 @@ inline procedure OUTER (OUTER_FORMAL : integer) =
 !
 OUTER(7);
 \end{lstlisting}
-\caption{Inlining examples: pseudo-source fragmment} \label{fig:inliningexamplespseudosourcefragment}
+\caption{Inlining examples: pseudo-source fragmment} 
+\label{fig:inliningexamplespseudosourcefragment}
 \end{figure}
 
 
@@ -1287,7 +1359,7 @@ approaches considered here.)
 
 The approaches are:
 
-\begin{itemize}[1.]
+\begin{enumerate}[1.]
 \item  Inline both OUTER and INNER in all cases
 
 \item Inline OUTER, multiple INNERs \\
@@ -1298,7 +1370,7 @@ inlining of OUTER.
 \item Inline OUTER, one INNER \\
 Compile INNER as a single normal subprogram which is called
 from every inlining of OUTER.
-\end{itemize}
+\end{enumerate}
 
 This discussion does not consider why a compiler might choose
 one of these approaches; it considers only how to describe
@@ -1307,37 +1379,39 @@ the result.
 In the examples that follow in this section, the debugging
 information entries are given mnemonic labels of the following
 form
-
-\begin{lstlisting}
-<io>.<ac>.<n>.<s>
-\end{lstlisting}
-
-where \begin{verbatim}<io>\end{verbatim}
+\begin{verbatim}
+    <io>.<ac>.<n>.<s>
+\end{verbatim}
+where
+\begin{description}
+\item[\textless io\textgreater]
 is either INNER or OUTER to indicate to which
 subprogram the debugging information entry applies, 
-\begin{verbatim}<ac>\end{verbatim}
+\item[\textless ac\textgreater]
 is either AI or CI to indicate ``abstract instance'' or
 ``concrete instance'' respectively, 
-\begin{verbatim}<n>\end{verbatim}
+\item[\textless n\textgreater]
 is the number of the
 alternative being considered, and 
-\begin{verbatim}<s>\end{verbatim}
+\item[\textless s\textgreater]
 is a sequence number that
-distinguishes the individual entries. There is no implication
+distinguishes the individual entries. 
+\end{description}
+There is no implication
 that symbolic labels, nor any particular naming convention,
 are required in actual use.
 
 For conciseness, declaration coordinates and call coordinates are omitted.
 
-\subsection{Alternative 1: inline both OUTER and INNER}
+\subsection{Alternative \#1: inline both OUTER and INNER}
 \label{app:inlinebothouterandinner}
 
 A suitable abstract instance for an alternative where both
 OUTER and INNER are always inlined is shown in 
-Figure \refersec{app:inliningexample1abstractinstance}
+Figure \refersec{fig:inliningexample1abstractinstance}.
 
 Notice in 
-Section \refersec{app:inliningexample1abstractinstance} 
+Figure \refersec{fig:inliningexample1abstractinstance} 
 that the debugging information entry for
 INNER (labelled INNER.AI.1.1) is nested in (is a child of)
 that for OUTER (labelled OUTER.AI.1.1). Nonetheless, the
@@ -1348,11 +1422,11 @@ The call of OUTER shown in
 Figure \refersec{fig:inliningexamplespseudosourcefragment}
 might be described as
 shown in 
-Section \refersec{app:inliningexample1concreteinstance}.
+Figure \refersec{fig:inliningexample1concreteinstance}.
 
 
-\subsubsection{Inlining example \#1: abstract instance}
-\label{app:inliningexample1abstractinstance}
+\begin{figure}[p]
+\begin{dwflisting}
 \begin{alltt}
     ! Abstract instance for OUTER
     ! \addtoindexx{abstract instance!example}
@@ -1396,10 +1470,13 @@ INNER.AI.1.3:
         ...
         0
 \end{alltt}
+\end{dwflisting}
+\caption{Inlining example \#1: abstract instance}
+\label{fig:inliningexample1abstractinstance}
+\end{figure}
 
-
-\subsubsection{Inlining example \#1: concrete instance}
-\label{app:inliningexample1concreteinstance}
+\begin{figure}[p]
+\begin{dwflisting}
 \begin{alltt}
 ! Concrete instance for call "OUTER(7)"
 ! \addtoindexx{concrete instance!example}
@@ -1448,8 +1525,12 @@ INNER.CI.1.3:
         ...
         0
 \end{alltt}
+\end{dwflisting}
+\caption{Inlining example \#1: concrete instance}
+\label{fig:inliningexample1concreteinstance}
+\end{figure}
 
-\subsection{Alternative 2: Inline OUTER, multiple INNERs}
+\subsection{Alternative \#2: Inline OUTER, multiple INNERs}
 \label{app:inlineoutermultiipleinners}
 
 
@@ -1462,16 +1543,16 @@ own normal instance of INNER.
 The abstract instance for OUTER,
 \addtoindexx{abstract instance!example}
 which includes INNER, is shown in 
-Section \refersec{app:inliningexample2abstractinstance}.
+Figure \refersec{fig:inliningexample2abstractinstance}.
 
 Note that the debugging information in this Figure differs from
 that in 
-Section \refersec{app:inliningexample1abstractinstance}
+Figure \refersec{fig:inliningexample1abstractinstance}
 in that INNER lacks a 
 \livelink{chap:DWATinline}{DW\-\_AT\-\_inline} attribute
 and therefore is not a distinct abstract instance. INNER
 is merely an out\dash of\dash line routine that is part of OUTER’s
-abstract instance. This is reflected in the Figure 70 by
+abstract instance. This is reflected in the Figure by
 \addtoindexx{abstract instance!example}
 the fact that the labels for INNER use the substring OUTER
 instead of INNER.
@@ -1479,10 +1560,10 @@ instead of INNER.
 A resulting 
 \addtoindexx{concrete instance!example}
 concrete inlined instance of OUTER is shown in
-Section \refersec{app:inliningexample2concreteinstance}.
+Figure \refersec{fig:inliningexample2concreteinstance}.
 
 Notice in 
-Section \refersec{app:inliningexample2concreteinstance}.
+Figure \refersec{fig:inliningexample2concreteinstance}.
 that OUTER is expanded as a concrete
 \addtoindexx{concrete instance!example}
 inlined instance, and that INNER is nested within it as a
@@ -1493,7 +1574,6 @@ attributes of INNER
 in the abstract instance of OUTER, and the low\dash level,
 \addtoindexx{abstract instance!example}
 instance\dash specific attributes of INNER (for example,
-
 \livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc}) are specified in 
 each concrete instance of OUTER.
 \addtoindexx{concrete instance!example}
@@ -1501,9 +1581,8 @@ The several calls of INNER within OUTER are compiled as normal
 calls to the instance of INNER that is specific to the same
 instance of OUTER that contains the calls.
 
-
-\subsubsection{Inlining example 2: abstract instance}
-\label{app:inliningexample2abstractinstance}
+\begin{figure}[t]
+\begin{dwflisting}
 \begin{alltt}
     ! Abstract instance for OUTER
     ! \addtoindex{abstract instance}
@@ -1545,9 +1624,13 @@ OUTER.AI.2.6:
         ...
         0
 \end{alltt}
+\end{dwflisting}
+\caption{Inlining example \#2: abstract instance}
+\label{fig:inliningexample2abstractinstance}
+\end{figure}
 
-\subsubsection{Inlining example 2: concrete instance}
-\label{app:inliningexample2concreteinstance}
+\begin{figure}[t]
+\begin{dwflisting}
 \begin{alltt}
 
     ! Concrete instance for call "OUTER(7)"
@@ -1594,8 +1677,12 @@ OUTER.CI.2.6:
         ...
         0
 \end{alltt}
+\end{dwflisting}
+\caption{Inlining example \#2: concrete instance}
+\label{fig:inliningexample2concreteinstance}
+\end{figure}
 
-\subsection{Alternative 3: inline OUTER, one normal INNER}
+\subsection{Alternative \#3: inline OUTER, one normal INNER}
 \label{app:inlineouteronenormalinner}
 
 In the third approach, one normal subprogram for INNER is
@@ -1603,7 +1690,7 @@ compiled which is called from all concrete inlined instances of
 \addtoindexx{concrete instance!example}
 \addtoindexx{abstract instance!example}
 OUTER. The abstract instance for OUTER is shown in 
-Section \refersec{app:inliningexample3abstractinstance}.
+Figure \refersec{fig:inliningexample3abstractinstance}.
 
 The most distinctive aspect of that Figure is that subprogram
 INNER exists only within the abstract instance of OUTER,
@@ -1612,19 +1699,28 @@ and not in OUTER’s concrete instance. In the abstract
 \addtoindexx{abstract instance!example}
 instance of OUTER, the description of INNER has the full
 complement of attributes that would be expected for a
-normal subprogram. While attributes such as \livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc},
-\livelink{chap:DWAThighpc}{DW\-\_AT\-\_high\-\_pc}, \livelink{chap:DWATlocation}{DW\-\_AT\-\_location}, and so on, typically are omitted
-from an abstract instance because they are not invariant across
+normal subprogram. 
+While attributes such as 
+\livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc},
+\livelink{chap:DWAThighpc}{DW\-\_AT\-\_high\-\_pc}, 
+\livelink{chap:DWATlocation}{DW\-\_AT\-\_location},
+and so on, typically are omitted
+\addtoindexx{high PC attribute}
+from 
+\addtoindexx{low PC attribute}
+an 
+\addtoindexx{location attribute}
+abstract instance because they are not invariant across
 instances of the containing abstract instance, in this case
 those same attributes are included precisely because they are
 invariant -- there is only one subprogram INNER to be described
 and every description is the same.
 
 A concrete inlined instance of OUTER is illustrated in
-\refersec{app:inliningexample3concreteinstance}.
+Figure \refersec{fig:inliningexample3concreteinstance}.
 
 Notice in 
-\refersec{app:inliningexample3abstractinstance}
+Figure \refersec{fig:inliningexample3abstractinstance}
 that there is no DWARF representation for
 INNER at all; the representation of INNER does not vary across
 instances of OUTER and the abstract instance of OUTER includes
@@ -1660,8 +1756,8 @@ entities that would give rise to this problem. (Neither extern
 variables nor static members require any form of static link
 for accessing purposes.)
 
-\subsubsection{Inlining example 3: abstract instance}
-\label{app:inliningexample3abstractinstance}
+\begin{figure}[t]
+\begin{dwflisting}
 \begin{alltt}
     ! Abstract instance for OUTER
     ! \addtoindexx{abstract instance!example}
@@ -1705,10 +1801,13 @@ OUTER.AI.3.6:
         ...
         0
 \end{alltt}
+\end{dwflisting}
+\caption{Inlining example \#3: abstract instance}
+\label{fig:inliningexample3abstractinstance}
+\end{figure}
 
-
-\subsubsection{Inlining example 3: concrete instance}
-\label{app:inliningexample3concreteinstance}
+\begin{figure}[t]
+\begin{dwflisting}
 \begin{alltt}
     ! Concrete instance for call "OUTER(7)"
     ! \addtoindexx{concrete instance!example}
@@ -1735,14 +1834,23 @@ OUTER.CI.3.3:
         ...
         0
 \end{alltt}
+\end{dwflisting}
+\caption{Inlining example \#3: concrete instance}
+\label{fig:inliningexample3concreteinstance}
+\end{figure}
 
+\clearpage
 \section{Constant Expression Example}
 \label{app:constantexpressionexample}
 C++ generalizes the notion of constant expressions to include
 constant expression user-defined literals and functions.
+The constant declarations in Figure \refersec{fig:constantexpressionscsource}
+can be represented as illustrated in 
+Figure \refersec{fig:constantexpressionsdwarfdescription}.
+
 
 \begin{figure}[here]
-\begin{lstlisting}
+\begin{lstlisting}[numbers=none]
 constexpr double mass = 9.8;
 constexpr int square (int x) { return x * x; }
 float arr[square(9)]; // square() called and inlined
@@ -1750,72 +1858,76 @@ float arr[square(9)]; // square() called and inlined
 \caption{Constant expressions: C++ source} \label{fig:constantexpressionscsource}
 \end{figure}
 
-These declarations can be represented as illustrated in 
-Section \refersec{app:constantexpressionsdwarfdescription}.
-
-\subsection{Constant expressions: DWARF description}
-\label{app:constantexpressionsdwarfdescription}
+\begin{figure}[h]
+\begin{dwflisting}
 \begin{alltt}
-
-      ! For variable mass
-      !
-1\$:  \livelink{chap:DWTAGconsttype}{DW\-\_TAG\-\_const\-\_type}
-        \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to "double")
-2\$:  \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable}
-        \livelink{chap:DWATname}{DW\-\_AT\-\_name}("mass")
-        \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 1\$)
-        \livelink{chap:DWATconstexpr}{DW\-\_AT\-\_const\-\_expr}(true)
-        \livelink{chap:DWATconstvalue}{DW\-\_AT\-\_const\-\_value}(9.8)
-      ! Abstract instance for square
-      !
-10\$: \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}
-        \livelink{chap:DWATname}{DW\-\_AT\-\_name}("square")
-        \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to "int")
-        \livelink{chap:DWATinline}{DW\-\_AT\-\_inline}(\livelink{chap:DWINLinlined}{DW\-\_INL\-\_inlined})
-11\$:   \livelink{chap:DWTAGformalparameter}{DW\-\_TAG\-\_formal\-\_parameter}
+        ! For variable mass
+        !
+1\$:     \livelink{chap:DWTAGconsttype}{DW\-\_TAG\-\_const\-\_type}
+            \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to "double")
+2\$:     \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable}
+            \livelink{chap:DWATname}{DW\-\_AT\-\_name}("mass")
+            \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 1\$)
+            \livelink{chap:DWATconstexpr}{DW\-\_AT\-\_const\-\_expr}(true)
+            \livelink{chap:DWATconstvalue}{DW\-\_AT\-\_const\-\_value}(9.8)
+        ! Abstract instance for square
+        !
+10\$:    \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}
+            \livelink{chap:DWATname}{DW\-\_AT\-\_name}("square")
+            \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to "int")
+            \livelink{chap:DWATinline}{DW\-\_AT\-\_inline}(\livelink{chap:DWINLinlined}{DW\-\_INL\-\_inlined})
+11\$:    \livelink{chap:DWTAGformalparameter}{DW\-\_TAG\-\_formal\-\_parameter}
             \livelink{chap:DWATname}{DW\-\_AT\-\_name}("x")
             \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to "int")
-      ! Concrete instance for square(9)
-      ! \addtoindexx{concrete instance!example}
-20\$: \livelink{chap:DWTAGinlinedsubroutine}{DW\-\_TAG\-\_inlined\-\_subroutine}
-        \livelink{chap:DWATabstractorigin}{DW\-\_AT\-\_abstract\-\_origin}(reference to 10\$)
-        \livelink{chap:DWATconstexpr}{DW\-\_AT\-\_const\-\_expr}(present)
-        \livelink{chap:DWATconstvalue}{DW\-\_AT\-\_const\-\_value}(81)
+        ! Concrete instance for square(9)
+        ! \addtoindexx{concrete instance!example}
+20\$:    \livelink{chap:DWTAGinlinedsubroutine}{DW\-\_TAG\-\_inlined\-\_subroutine}
+            \livelink{chap:DWATabstractorigin}{DW\-\_AT\-\_abstract\-\_origin}(reference to 10\$)
+            \livelink{chap:DWATconstexpr}{DW\-\_AT\-\_const\-\_expr}(present)
+            \livelink{chap:DWATconstvalue}{DW\-\_AT\-\_const\-\_value}(81)
         \livelink{chap:DWTAGformalparameter}{DW\-\_TAG\-\_formal\-\_parameter}
             \livelink{chap:DWATabstractorigin}{DW\-\_AT\-\_abstract\-\_origin}(reference to 11\$)
             \livelink{chap:DWATconstvalue}{DW\-\_AT\-\_const\-\_value}(9)
-      ! Anonymous array type for arr
-      !
-30\$: \livelink{chap:DWTAGarraytype}{DW\-\_TAG\-\_array\-\_type}
+        ! Anonymous array type for arr
+        !
+30\$:    \livelink{chap:DWTAGarraytype}{DW\-\_TAG\-\_array\-\_type}
         \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to "float")
-        \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size}(324) ! 81*4
+            \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size}(324) ! 81*4
         \livelink{chap:DWTAGsubrangetype}{DW\-\_TAG\-\_subrange\-\_type}
             \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to "int")
             \livelink{chap:DWATupperbound}{DW\-\_AT\-\_upper\-\_bound}(reference to 20\$)
-      ! Variable arr
-      !
-40\$: \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable}
-        \livelink{chap:DWATname}{DW\-\_AT\-\_name}("arr")
-        \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 30\$)
+        ! Variable arr
+        !
+40\$:    \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable}
+            \livelink{chap:DWATname}{DW\-\_AT\-\_name}("arr")
+            \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 30\$)
 \end{alltt}
-
+\end{dwflisting}
+\caption{Constant expressions: DWARF description}
+\label{fig:constantexpressionsdwarfdescription}
+\end{figure}
 
 \section{Unicode Character Example}
 \label{app:unicodecharacterexample}
-
-Unicode character encodings can be described in DWARF as
-illustrated in 
-Section \refersec{app:unicodecharacterexamplesub}.
-
-\begin{lstlisting}
+\addtoindexx{Unicode|see {\textit{also} UTF-8}}
+The \addtoindex{Unicode} character encodings in
+Figure \refersec{fig:unicodecharacterexamplesource}
+can be described in DWARF as illustrated in 
+Figure \refersec{fig:unicodecharacterexampledwarfdescription}.
+
+\begin{figure}[h]
+\begin{lstlisting}[numbers=none]
 // C++ source
 //
 char16_t chr_a = u'h';
 char32_t chr_b = U'h';
 \end{lstlisting}
+\caption{Unicode character example: source}
+\label{fig:unicodecharacterexamplesource}
+\end{figure}
 
-\subsection{Unicode Character Example}
-\label{app:unicodecharacterexamplesub}
+\begin{figure}[h]
+\begin{dwflisting}
 \begin{alltt}
 
 ! DWARF description
@@ -1835,25 +1947,34 @@ char32_t chr_b = U'h';
         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("chr\_b")
         \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 2\$)
 \end{alltt}
-
+\end{dwflisting}
+\caption{Unicode character example: DWARF description}
+\label{fig:unicodecharacterexampledwarfdescription}
+\end{figure}
 
 
 \section{Type-Safe Enumeration Example}
 \label{app:typesafeenumerationexample}
 
+The \addtoindex{C++} type\dash safe enumerations in
+\addtoindexx{type-safe enumeration}
+Figure \refersec{fig:ctypesafeenumerationexamplesource}
+can be described in DWARF as illustrated in 
+Figure \refersec{fig:ctypesafeenumerationexampledwarf}.
 
-C++ type\dash safe enumerations can be described in DWARF as illustrated in 
-Section \refersec{app:ctypesafeenumerationexample}.
-
-\begin{lstlisting}
+\begin{figure}[H]
+\begin{lstlisting}[numbers=none]
 // C++ source
 //
 enum class E { E1, E2=100 };
 E e1;
 \end{lstlisting}
+\caption{Type-safe enumeration example: source}
+\label{fig:ctypesafeenumerationexamplesource}
+\end{figure}
 
-\subsection{C++ type-safe enumeration example}
-\label{app:ctypesafeenumerationexample}
+\begin{figure}[H]
+\begin{dwflisting}
 \begin{alltt}
 ! DWARF description
 !
@@ -1872,15 +1993,21 @@ E e1;
         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("e1")
         \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 11\$)
 \end{alltt}
+\end{dwflisting}
+\caption{Type-safe enumeration example: DWARF description}
+\label{fig:ctypesafeenumerationexampledwarf}
+\end{figure}
 
-\section{Template Example}
-\label{app:templateexample}
-
-C++ templates can be described in DWARF as illustrated in 
-Section \refersec{app:ctemplateexample1}.
 
+\section{Template Examples}
+\label{app:templateexample}
 
+The C++ template example in
+Figure \refersec{fig:ctemplateexample1source}
+can be described in DWARF as illustrated in 
+Figure \refersec{fig:ctemplateexample1dwarf}.
 
+\begin{figure}[h]
 \begin{lstlisting}
 // C++ source
 //
@@ -1890,9 +2017,12 @@ struct wrapper {
 };
 wrapper<int> obj;
 \end{lstlisting}
+\caption{C++ template example \#1: source}
+\label{fig:ctemplateexample1source}
+\end{figure}
 
-\subsection{C++ template example 1}
-\label{app:ctemplateexample1}
+\begin{figure}[h]
+\begin{dwflisting}
 \begin{alltt}
 ! DWARF description
 !
@@ -1908,20 +2038,26 @@ wrapper<int> obj;
         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("obj")
         \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 11\$)
 \end{alltt}
+\end{dwflisting}
+\caption{C++ template example \#1: DWARF description}
+\label{fig:ctemplateexample1dwarf}
+\end{figure}
 
 The actual type of the component comp is int, but in the DWARF
-the type references the \livelink{chap:DWTAGtemplatetypeparameter}{DW\-\_TAG\-\_template\-\_type\-\_parameter} for
-T, which in turn references int. This implies that in the
+the type references the
+\livelink{chap:DWTAGtemplatetypeparameter}{DW\-\_TAG\-\_template\-\_type\-\_parameter}
+for T, which in turn references int. This implies that in the
 original template comp was of type T and that was replaced
-with int in the instance.  There exist situations where it is
+with int in the instance. There exist situations where it is
 not possible for the DWARF to imply anything about the nature
 of the original template. 
 
-Consider following C++ source and DWARF 
-that can describe it in
-Section \refersec{app:ctemplateexample2}.
-
+Consider the C++ template source in
+Figure \refersec{fig:ctemplateexample2source}
+and the DWARF that can describe it in
+Figure \refersec{fig:ctemplateexample2dwarf}.
 
+\begin{figure}[h]
 \begin{lstlisting}
 // C++ source
 //
@@ -1937,9 +2073,12 @@ Section \refersec{app:ctemplateexample2}.
     wrapper<int> obj;
     consume(obj);
 \end{lstlisting}
+\caption{C++ template example \#2: source}
+\label{ctemplateexample2source}
+\end{figure}
 
-\subsection{C++ template example 2}
-\label{app:ctemplateexample2}
+\begin{figure}[h]
+\begin{dwflisting}
 \begin{alltt}
 ! DWARF description
 !
@@ -1963,56 +2102,43 @@ Section \refersec{app:ctemplateexample2}.
             \livelink{chap:DWATname}{DW\-\_AT\-\_name}("formal")
             \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 11\$)
 \end{alltt}
+\end{dwflisting}
+\caption{C++ template example \#2: DWARF description}
+\label{fig:ctemplateexample2dwarf}
+\end{figure}
 
-In the \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram} entry for the instance of consume,
-U is described as 
-int. 
-The type of formal is 
-\begin{alltt}
-wrapper<U>
-\end{alltt}
- in
+In the \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram} 
+entry for the instance of consume, U is described as int. 
+The type of formal is \texttt{wrapper\textless U\textgreater} in
 the source. DWARF only represents instantiations of templates;
-there is no entry which represents 
-\begin{alltt}
-wrapper<U>, 
-\end{alltt}
+there is no entry which represents \texttt{wrapper\textless U\textgreater} 
 which is neither
 a template parameter nor a template instantiation. The type
-of formal is described as 
-\begin{alltt}
-wrapper<int>, 
-\end{alltt}
-the instantiation of
-\begin{alltt}
-wrapper<U>, 
-\end{alltt}
+of formal is described as \texttt{wrapper\textless int\textgreater},
+the instantiation of \texttt{wrapper\textless U\textgreater},
 in the \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute at 
 23\$. 
 There is no
 description of the relationship between template type parameter
-T at 12\$ and U at 
-22\$ which was used to instantiate 
-\begin{alltt}
-wrapper<U>.
-\end{alltt}
+T at 12\$ and U at 22\$ which was used to instantiate
+\texttt{wrapper\textless U\textgreater}.
 
 A consequence of this is that the DWARF information would
 not distinguish between the existing example and one where
 the formal of consume were declared in the source to be
-\begin{alltt}
-wrapper<int>.
-\end{alltt}
+\texttt{wrapper\textless int\textgreater}.
+
 
 \section{Template Alias Examples}
 \label{app:templatealiasexample}
 
-C++ template aliases can be described in DWARF as illustrated in 
-Section \refersec{app:templatealiasexample1}
-an
-Section \refersec{app:templatealiasexample2}.
-
+The \addtoindex{C++} template alias shown in
+Figure \refersec{fig:ctemplatealiasexample1source}
+can be described in DWARF as illustrate
+\addtoindexx{template alias example} in 
+Figure \refersec{fig:ctemplatealiasexample1dwarf}.
 
+\begin{figure}[h]
 \begin{lstlisting}
 // C++ source, template alias example 1
 //
@@ -2024,10 +2150,13 @@ struct Alpha {
 template<typename V> using Beta = Alpha<V,V>;
 Beta<long> b;
 \end{lstlisting}
+\caption{C++ template alias example \#1: source}
+\label{fig:ctemplatealiasexample1source}
+\end{figure}
 
-
-\subsection{template alias example 1}
-\label{app:templatealiasexample1}
+\begin{figure}[h]
+\addtoindexx{template alias example 1}
+\begin{dwflisting}
 \begin{alltt}
 ! DWARF representation for variable 'b'
 !
@@ -2055,8 +2184,18 @@ Beta<long> b;
         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("b")
         \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 25\$)
 \end{alltt}
+\end{dwflisting}
+\caption{C++ template alias example \#1: DWARF description}
+\label{fig:ctemplatealiasexample1dwarf}
+\end{figure}
 
+Similarly, the \addtoindex{C++} template alias shown in
+Figure \refersec{fig:ctemplatealiasexample2source}
+can be described in DWARF as illustrated 
+\addtoindexx{template alias example} in 
+Figure \refersec{fig:ctemplatealiasexample2dwarf}.
 
+\begin{figure}[h]
 \begin{lstlisting}
 // C++ source, template alias example 2
 //
@@ -2066,10 +2205,13 @@ template<class T> using Z = Y<T>;
 X<Y<int>> y;
 X<Z<int>> z;
 \end{lstlisting}
+\caption{C++ template alias example \#2: source}
+\label{fig:ctemplatealiasexample2source}
+\end{figure}
 
-
-\subsection{template alias example 2}
-\label{app:templatealiasexample2}
+\begin{figure}[h]
+\addtoindexx{template alias example 2}
+\begin{dwflisting}
 \begin{alltt}
 ! DWARF representation for X<Y<int>>
 !
@@ -2107,3 +2249,7 @@ using Z = Y<int>;
         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("z")
         \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to \$42)
 \end{alltt}
+\end{dwflisting}
+\caption{C++ template alias example \#2: DWARF description}
+\label{fig:ctemplatealiasexample2dwarf}
+\end{figure}
\ No newline at end of file