First draft of Version 5, incorporating numerous approved changes
[dwarf-doc.git] / dwarf5 / latexdoc / otherdebugginginformation.tex
index d9f769b..0a90f8c 100644 (file)
@@ -3,19 +3,28 @@
 % references to chapter 7 look like  {datarep:...}
 This section describes debugging information that is not
 represented in the form of debugging information entries and
-is not contained within a \addtoindex{.debug\_info} or 
-\addtoindex{.debug\_types} section.
+is not contained within a \dotdebuginfo{} or 
+\dotdebugtypes{} section.
 
 In the descriptions that follow, these terms are used to
 specify the representation of DWARF sections:
-
-Initial length, section offset and section length, which are
+\begin{itemize}
+\item
+Initial length, section offset and 
+\addtoindex{section length}, which are
 defined in 
 Sections \refersec{datarep:locationdescriptions} and 
 \refersec{datarep:32bitand64bitdwarfformats}.
-
-Sbyte, ubyte, uhalf, and uword, which are defined in 
+\item
+Sbyte, 
+\addtoindex{ubyte}, 
+\addtoindex{uhalf}, and 
+\addtoindex{uword}, 
+which 
+\addtoindexx{sbyte}
+are defined in 
 Section \refersec{datarep:integerrepresentationnames}.
+\end{itemize}
 
 \section{Accelerated Access}
 \label{chap:acceleratedaccess}
@@ -60,12 +69,14 @@ more condensed format.
 
 \subsection{Lookup by Name}
 
-For lookup by name, two tables are maintained in separate
-\addtoindex{accelerated access!by name}
+For lookup by name, 
+\addtoindexx{lookup!by name}
+two tables are maintained in separate
+\addtoindexx{accelerated access!by name}
 object file sections named 
-\addtoindex{.debug\_pubnames} for objects and
+\dotdebugpubnames{} for objects and
 functions, and 
-\addtoindex{.debug\_pubtypes}
+\dotdebugpubtypes{}
 for types. Each table consists
 of sets of variable length entries. Each set describes the
 names of global objects and functions, or global types,
@@ -76,32 +87,42 @@ information entries owned by a single compilation unit.
 are definitions in every compilation unit containing the
 class declaration, but if there is no concrete out\dash of\dash line
 instance there is no need to have a 
-\addtoindex{.debug\_pubnames} entry
+\dotdebugpubnames{} entry
 for the member function.}
 
 Each set begins with a header containing four values:
-\begin{enumerate}[1.]
+\begin{enumerate}[1. ]
 
-\item unit\_length (initial length) \\
+\item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
+\addtoindexx{unit\_length}
 The total length of the all of the entries for that set,
 not including the length field itself 
-(see Section \refersec{datarep:locationdescriptions}).
+(see Section \refersec{datarep:initiallengthvalues}).
 
-\item  version (uhalf) \\
-A version number 
+\item  version (\addtoindex{uhalf}) \\
+A version number
+\addtoindexx{version number!name lookup table}
+\addtoindexx{version number!type lookup table} 
 (see Section \refersec{datarep:namelookuptables}). 
 This number is specific
 to the name lookup table and is independent of the DWARF
 version number.
 
 \item debug\_info\_offset (section offset) \\
-The offset from the beginning of the 
-\addtoindex{.debug\_info} section of
+The 
+\addtoindexx{section offset!in .debug\_pubtypes header}
+offset 
+\addtoindexx{section offset!in .debug\_pubtypes header}
+from the beginning of the 
+\dotdebuginfo{} section of
 the compilation unit header referenced by the set.
 
 \item debug\_info\_length (section length) \\
-The size in bytes of the contents of the 
-\addtoindex{.debug\_info} section
+\addtoindexx{section length!in .debug\_pubnames header}
+The 
+\addtoindexx{section length!in .debug\_pubtypes header}
+size in bytes of the contents of the 
+\dotdebuginfo{} section
 generated to represent that compilation unit.
 \end{enumerate}
 
@@ -110,7 +131,7 @@ pairs. Each pair consists of the section offset from the
 beginning of the compilation unit corresponding to the current
 set to the debugging information entry for the given object,
 followed by a null\dash terminated character string representing
-the name of the object as given by the \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+the name of the object as given by the \livelink{chap:DWATname}{DW\_AT\_name} attribute
 of the referenced debugging information entry. Each set of
 names is terminated by an offset field containing zero (and
 no following string).
@@ -119,54 +140,56 @@ no following string).
 In the case of the name of a function member or static data
 member of a C++ structure, class or union, the name presented
 in the 
-\addtoindex{.debug\_pubnames
+\dotdebugpubnames{
 section is not the simple name given
-by the \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute of the referenced debugging
+by the \livelink{chap:DWATname}{DW\_AT\_name} attribute of the referenced debugging
 information entry, but rather the fully qualified name of
 the data or function member.
 
 \subsection{Lookup by Address}
 
-For lookup by address, a table is maintained in a separate
-\addtoindex{accelerated access!by address}
+For 
+\addtoindexx{lookup!by address}
+lookup by address, a table is maintained in a separate
+\addtoindexx{accelerated access!by address}
 object file section called 
-\addtoindex{.debug\_aranges}. The table consists
+\dotdebugaranges{}. The table consists
 of sets of variable length entries, each set describing the
-portion of the programs address space that is covered by
+portion of the program\textquoteright s address space that is covered by
 a single compilation unit.
 
 Each set begins with a header containing five values:
-
-\begin{enumerate}[1.]
-
-\item unit\_length (initial length) \\
+\begin{enumerate}[1. ]
+\item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
+\addttindexx{unit\_length}
 The total length of all of the
 entries for that set, not including the length field itself
 (see Section \refersec{datarep:initiallengthvalues}).
 
-\item version (uhalf) \\
-A version number 
+\item version (\addtoindex{uhalf}) \\
+A version number\addtoindexx{version number!address lookup table} 
 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}). 
-This
-number is specific to the address lookup table and is
+This number is specific to the address lookup table and is
 independent of the DWARF version number.
 
 \item debug\_info\_offset (section offset) \\
 The offset from the
-beginning of the \addtoindex{.debug\_info} or 
-\addtoindex{.debug\_types} section of the
+\addtoindexx{section offset!in .debug\_pubnames header}
+beginning of the \dotdebuginfo{} section of the
 compilation unit header referenced by the set.
 
-\item address\_size (ubyte) \\
-The size of an address in bytes on
+\item address\_size (\addtoindex{ubyte}) \\
+The \addtoindex{size of an address}
+in bytes on
 \addtoindexx{address\_size}
 the target architecture. For 
 \addtoindexx{address space!segmented}
 segmented addressing, this is
 the size of the offset portion of the address.
 
-\item segment\_size (ubyte) \\
+\item segment\_size (\addtoindex{ubyte}) \\
 The size of a segment selector in
+\addtoindexx{segment\_size}
 bytes on the target architecture. If the target system uses
 a flat address space, this value is 0.
 
@@ -179,7 +202,9 @@ segment selector, the beginning address within that segment
 of a range of text or data covered by some entry owned by
 the corresponding compilation unit, followed by the non\dash zero
 length of that range. A particular set is terminated by an
-entry consisting of three zeroes. When the segment\_size value
+entry consisting of three zeroes. 
+When the 
+\addtoindex{segment\_size} value
 is zero in the header, the segment selector is omitted so that
 each descriptor is just a pair, including the terminating
 entry. By scanning the table, a debugger can quickly decide
@@ -196,6 +221,7 @@ multiple address range descriptors for that compilation unit.}
 \section{Line Number Information}
 \label{chap:linenumberinformation}
 \textit{A source\dash level debugger will need to know how to
+\addtoindexx{line number information|see{\textit{also} statement list attribute}}
 associate locations in the source files with the corresponding
 machine instruction addresses in the executable object or
 the shared objects used by that executable object. Such an
@@ -209,45 +235,48 @@ or statement to statement.}
 
 Line number information generated for a compilation unit is
 represented in the 
-\addtoindex{.debug\_line} section of an object file and
+\dotdebugline{} section of an object file and
 is referenced by a corresponding compilation unit debugging
 information entry 
-(see Section \refersec{chap:generalsubroutineandentrypointinformation}) 
-in the \addtoindex{.debug\_info}
+(see Section \refersec{chap:normalandpartialcompilationunitentries}) 
+in the \dotdebuginfo{}
 section.
 
 \textit{Some computer architectures employ more than one instruction
-set (for example, the ARM and MIPS architectures support
+set (for example, the ARM 
 \addtoindexx{ARM instruction set architecture}
+and 
+MIPS architectures support
+\addtoindexx{MIPS instruction set architecture}
 a 32\dash bit as well as a 16\dash bit instruction set). Because the
 instruction set is a function of the program counter, it is
 convenient to encode the applicable instruction set in the
-\addtoindex{.debug\_line} section as well.}
+\dotdebugline{} section as well.}
 
 \textit{If space were not a consideration, the information provided
-in the \addtoindex{.debug\_line
+in the \dotdebugline{
 section could be represented as a large
 matrix, with one row for each instruction in the emitted
 object code. The matrix would have columns for:}
-
 \begin{itemize}
 \item \textit{the source file name}
 \item \textit{the source line number}
 \item \textit{the source column number}
-\item \textit{whether this insruction is the beginning of a \addtoindex{basic block}}
+\item \textit{whether this instruction is the beginning of a source statement}
+\item \textit{whether this instruction is the beginning of a \addtoindex{basic block}}
 \item \textit{and so on}
 \end{itemize}
-
 \textit{Such a matrix, however, would be impractically large. We
 shrink it with two techniques. First, we delete from
 the matrix each row whose file, line, source column and
-discriminator information is identical with that of its
+\addtoindex{discriminator} information 
+is identical with that of its
 predecessors. Any deleted row would never be the beginning of
 a source statement. Second, we design a byte\dash coded language
 for a state machine and store a stream of bytes in the object
 file instead of the matrix. This language can be much more
 compact than the matrix. When a consumer of the line number
-information executes, it must ``run'' the state machine
+information executes, it must \doublequote{run} the state machine
 to generate the matrix for each compilation unit it is
 interested in.  The concept of an encoded matrix also leaves
 room for expansion. In the future, columns can be added to the
@@ -264,7 +293,7 @@ The following terms are used in the description of the line
 number information format:
 
 
-\begin{tabular} {lp{9cm}}
+\begin{longtable} {lp{9cm}}
 state machine &
 The hypothetical machine used by a consumer of the line number
 information to expand the byte\dash coded 
@@ -286,20 +315,20 @@ procedure invocation is defined to be an exit from a
 necessarily correspond to a specific source code
 construct.} \\
 
+
 sequence &
 A series of contiguous target machine instructions. One compilation unit
 may emit multiple sequences (that is, not all instructions within a
 compilation unit are assumed to be contiguous). \\
-\end{tabular}
+\end{longtable}
 
 \subsection{State Machine Registers}
 \label{chap:statemachineregisters}
-
 The line number information state machine has the following 
 registers:
 \begin{longtable}{l|p{9cm}}
-  \caption{State Machine Registers } \\
-  \hline \\ \bfseries Register name&\bfseries Meaning\\ \hline
+  \caption{State machine registers } \\
+  \hline \bfseries Register name&\bfseries Meaning\\ \hline
 \endfirsthead
   \bfseries Register name&\bfseries Meaning\\ \hline
 \endhead
@@ -307,69 +336,72 @@ registers:
 \endfoot
   \hline
 \endlastfoot
-\addtoindexi{address}{address register!in line number machine}&
+\addtoindexi{\texttt{address}}{address register!in line number machine}&
 The program\dash counter value corresponding to a machine instruction
 generated by the compiler. \\
 
-op\_index &
+\addttindex{op\_index} &
 An unsigned integer representing the index of an operation within a VLIW
 instruction. The index of the first operation is 0. For non\dash VLIW
 architectures, this register will always be 0.
 
-The address and op\_index registers, taken together, form an operation
-pointer that can reference any individual operation with the instruction
+The \texttt{address} and \addttindex{op\_index} registers,
+taken together, form an operation
+pointer that can reference any individual operation within the instruction
 stream. \\
 
 
-file &
+\addttindex{file} &
 An unsigned integer indicating the identity of the source file
 corresponding to a machine instruction. \\
 
-line &
+\addttindex{line} &
 An unsigned integer indicating a source line number. Lines are numbered
 beginning at 1. The compiler may emit the value 0 in cases where an
 instruction cannot be attributed to any source line. \\
 
-column &
+\addttindex{column} &
 An unsigned integer indicating a column number within a source line.
 Columns are numbered beginning at 1. The value 0 is reserved to indicate
-that a statement begins at the ``left edge'' of the line. \\
+that a statement begins at the \doublequote{left edge} of the line. \\
 
-is\_stmt &
+\addttindex{is\_stmt} &
 A boolean indicating that the current instruction is a recommended
 breakpoint location. A recommended breakpoint location 
-is intended to ``represent'' a line, a 
+is intended to \doublequote{represent} a line, a 
 statement and/or a semantically distinct subpart of a
 statement. \\
 
-basic\_block  &
+\addttindex{basic\_block}  &
 A boolean indicating that the current instruction is the beginning of a
 \addtoindex{basic block}. \\
 
-end\_sequence &
+\addttindex{end\_sequence} &
 A boolean indicating that the current address is that of the first byte after
-the end of a sequence of target machine instructions. end\_sequence
+the end of a sequence of target machine instructions. 
+\addttindex{end\_sequence}
 terminates a sequence of lines; therefore other information in the same
 row is not meaningful. \\
 
-prologue\_end &
+\addttindex{prologue\_end} &
 A boolean indicating that the current address is one (of possibly many)
 where execution should be suspended for an entry breakpoint of a
 function. \\
 
-epilogue\_begin &
+\addttindex{epilogue\_begin} &
 A boolean indicating that the current address is one (of possibly many)
 where execution should be suspended for an exit breakpoint of a function. \\
 
-isa &
+\addttindex{isa} &
 An unsigned integer whose value encodes the applicable
 instruction set architecture for the current instruction.
-The encoding of instruction sets should be shared by all
+
+\textit{The encoding of instruction sets should be shared by all
 users of a given architecture. It is recommended that this
 encoding be defined by the ABI authoring committee for each
-architecture. \\
+architecture.} \\
 
-discriminator &
+\addttindex{discriminator} &
 An unsigned integer identifying the block to which the
 current instruction belongs. Discriminator values are assigned
 arbitrarily by the DWARF producer and serve to distinguish
@@ -379,55 +411,58 @@ exists for a given source position, the discriminator value
 should be zero. \\
 \end{longtable}
 
+\clearpage      % Keep this sentence with the following table
 At the beginning  of each sequence within a line number
 program, the state of the registers is:
-
-\begin{tabular}{lp{8cm}}
-address & 0 \\
-op\_index & 0 \\
-file & 1 \\
-line & 1 \\
-column & 0 \\
-is\_stmt & determined by default\_is\_stmt in the line number program header \\
-basic\_block & ``false'' \addtoindexx{basic block} \\
-end\_sequence & ``false'' \\
-prologue\_end & ``false'' \\
-epilogue\_begin & ``false'' \\
-isa & 0 \\
-discriminator & 0 \\
+\begin{center}
+\begin{tabular}{lp{9.5cm}}
+\texttt{address} & 0 \\
+\addttindex{op\_index} & 0 \\
+\texttt{file} & 1 \\
+\texttt{line} & 1 \\
+\texttt{column} & 0 \\
+\addttindex{is\_stmt} & determined by \addttindex{default\_is\_stmt} 
+                                                                       in the line number program header \\
+\addttindex{basic\_block}    & \doublequote{false} \addtoindexx{basic block} \\
+\addttindex{end\_sequence}   & \doublequote{false} \\
+\addttindex{prologue\_end}   & \doublequote{false} \\
+\addttindex{epilogue\_begin} & \doublequote{false} \\
+\addttindex{isa} & 0 \\
+\addttindex{discriminator} & 0 \\
 \end{tabular}
+\end{center}
 
-\textit{The isa value 0 specifies that the instruction set is the
+\textit{The 
+\addttindex{isa} value 0 specifies that the instruction set is the
 architecturally determined default instruction set. This may
 be fixed by the ABI, or it may be specified by other means,
 for example, by the object file description.}
-
 \subsection{Line Number Program Instructions}
-
 The state machine instructions in a line number program belong to one of three categories:
 
-\begin{tabular}{lp{10cm}}
-special opcodes &
-These have a ubyte opcode field and no operands.
+\begin{enumerate}[1. ]
+\item special opcodes \\
+These have a \addtoindex{ubyte} opcode field and no operands.\vspace{1ex}
 
 \textit{Most of the instructions in a 
-line number program are special opcodes.} \\
+line number program are special opcodes.}
 
-standard opcodes &
-These have a ubyte opcode field which may be followed by zero or more
-LEB128 operands (except for 
-\livelink{chap:DWLNSfixedadvancepc}{DW\-\_LNS\-\_fixed\-\_advance\-\_pc}, see below).
+\item standard opcodes \\
+These have a \addtoindex{ubyte} opcode field which may be followed by zero or more
+\addtoindex{LEB128} operands (except for 
+\mbox{\livelink{chap:DWLNSfixedadvancepc}{DW\_LNS\_fixed\_advance\_pc},} see below).
 The opcode implies the number of operands and their meanings, but the
 line number program header also specifies the number of operands for
-each standard opcode. \\
+each standard opcode.
 
-extended opcodes &
+\needlines{6}
+\item extended opcodes \\
 These have a multiple byte format. The first byte is zero; the next bytes
-are an unsigned LEB128 integer giving the number of bytes in the
+are an unsigned LEB128\addtoindexx{LEB128!unsigned} integer giving the number of bytes in the
 instruction itself (does not include the first zero byte or the size). The
-remaining bytes are the instruction itself (which begins with a ubyte
+remaining bytes are the instruction itself (which begins with a \addtoindex{ubyte}
 extended opcode). \\
-\end{tabular}
+\end{enumerate}
 
 
 \subsection{The Line Number Program Header}
@@ -442,49 +477,64 @@ used throughout the rest of the line number program.
 The line number program for each compilation unit begins with
 a header containing the following fields in order:
 
-\begin{enumerate}[1.]
-\item unit\_length (initial length)  \\
+\begin{enumerate}[1. ]
+\item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length})  \\
+\addttindexx{unit\_length}
 The size in bytes of the line number information for this
-compilation unit, not including the unit\_length field itself
+compilation unit, not including the length field itself
 (see Section \refersec{datarep:initiallengthvalues}). 
 
-\item version (uhalf) 
-A version number 
-(see Appendix \refersec{app:dwarfsectionversionnumbersinformative}). 
+\item \texttt{version} (\addtoindex{uhalf}) \\
+A version number\addtoindexx{version number!line number information} 
+(see Appendix \refersec{datarep:linenumberinformation}). 
 This number is specific to
 the line number information and is independent of the DWARF
 version number. 
 
-\item header\_length  \\
-The number of bytes following the header\_length field to the
+\item \texttt{header\_length}  \\
+The number of bytes following the \addttindex{header\_length} field to the
 beginning of the first byte of the line number program itself.
-In the 32\dash bit DWARF format, this is a 4\dash byte unsigned
-length; in the 64\dash bit DWARF format, this field is an
+In the \thirtytwobitdwarfformat, this is a 4\dash byte unsigned
+length; in the \sixtyfourbitdwarfformat, this field is an
 8\dash byte unsigned length 
 (see Section \refersec{datarep:32bitand64bitdwarfformats}). 
 
-\item minimum\_instruction\_length (ubyte)  \\
+\item \texttt{minimum\_instruction\_length} (\addtoindex{ubyte})  \\
+\addttindexx{minimum\_instruction\_length}
 The size in bytes of the smallest target machine
 instruction. Line number program opcodes that alter
-the address and op\_index registers use this and
-maximum\-\_operations\-\_per\-\_instruction in their calculations. 
-
-\item maximum\_operations\_per\_instruction (ubyte) \\
-The maximum number of individual operations that may be
+the \texttt{address} and \addttindex{op\_index}
+registers use this and
+\addttindex{maximum\_operations\_per\_instruction}
+(see following) in their calculations. 
+
+\needlines{9}
+\item \texttt{maximum\_operations\_per\_instruction} (\addtoindex{ubyte}) \\
+The 
+\addttindexx{maximum\_operations\_per\_instruction}
+maximum number of individual operations that may be
 encoded in an instruction. Line number program opcodes
-that alter the address and op\_index registers use this and
-minimum\_instruction\_length in their calculations.  For non-VLIW
-architectures, this field is 1, the op\_index register is always
-0, and the operation pointer is simply the address register.
+that alter the \texttt{address} and 
+\addttindex{op\_index} registers use this and
+\addttindex{minimum\_instruction\_length} (see preceeding)
+in their calculations.
 
-\item default\_is\_stmt (ubyte) \\
-The initial value of the is\_stmt register.  
+For non-VLIW
+architectures, this field is 1, the \addttindex{op\_index} register is always
+0, and the operation pointer is simply the \texttt{address} register.
+
+\needlines{4}
+\item \texttt{default\_is\_stmt} (\addtoindex{ubyte}) \\
+\addttindexx{default\_is\_stmt}
+The initial value of the \addttindex{is\_stmt} register.  
 
 \textit{A simple approach
 to building line number information when machine instructions
 are emitted in an order corresponding to the source program
-is to set default\_is\_stmt to ``true'' and to not change the
-value of the is\_stmt register within the line number program.
+is to set \addttindex{default\_is\_stmt}
+to \doublequote{true} and to not change the
+value of the \addttindex{is\_stmt} register 
+within the line number program.
 One matrix entry is produced for each line that has code
 generated for it. The effect is that every entry in the
 matrix recommends the beginning of each represented line as
@@ -494,48 +544,67 @@ unoptimized code.}
 \textit{A more sophisticated approach might involve multiple entries in
 the matrix for a line number; in this case, at least one entry
 (often but not necessarily only one) specifies a recommended
-breakpoint location for the line number. \livelink{chap:DWLNSnegatestmt}{DW\-\_LNS\-\_negate\-\_stmt}
+breakpoint location for the line number. \livelink{chap:DWLNSnegatestmt}{DW\_LNS\_negate\_stmt}
 opcodes in the line number program control which matrix entries
-constitute such a recommendation and default\_is\_stmt might
-be either ``true'' or ``false''. This approach might be
+constitute such a recommendation and 
+\addttindex{default\_is\_stmt} might
+be either \doublequote{true} or \doublequote{false.} This approach might be
 used as part of support for debugging optimized code.}
 
-\item line\_base (sbyte) \\
+\item \texttt{line\_base} (\addtoindex{sbyte}) \\
+\addttindexx{line\_base}
 This parameter affects the meaning of the special opcodes. See below.
 
-\item line\_range (ubyte) \\
+\item \texttt{line\_range} (\addtoindex{ubyte}) \\
+\addttindexx{line\_range}
 This parameter affects the meaning of the special opcodes. See below.
 
-\item opcode\_base (ubyte) \\
-The number assigned to the first special opcode.
+\item \texttt{opcode\_base} (\addtoindex{ubyte}) \\
+The 
+\addttindexx{opcode\_base}
+number assigned to the first special opcode.
 
 \textit{Opcode base is typically one greater than the highest-numbered
+\addttindexx{opcode\_base}
 standard opcode defined for the specified version of the line
-number information (12 in DWARF Version 3 and Version 4, 9 in
-Version 2).  If opcode\_base is less than the typical value,
+number information (12 in DWARF Versions 3, 4 and 5,
+\addtoindexx{DWARF Version 3}
+\addtoindexx{DWARF Version 4}
+\addtoindexx{DWARF Version 5}
+and 9 in
+\addtoindexx{DWARF Version 2}
+Version 2).  
+If opcode\_base is less than the typical value,
+\addttindexx{opcode\_base}
 then standard opcode numbers greater than or equal to the
 opcode base are not used in the line number table of this unit
-(and the codes are treated as special opcodes). If opcode\_base
+(and the codes are treated as special opcodes). If \texttt{opcode\_base}
 is greater than the typical value, then the numbers between
 that of the highest standard opcode and the first special
 opcode (not inclusive) are used for vendor specific extensions.}
 
-\item standard\_opcode\_lengths (array of ubyte) \\
-This array specifies the number of LEB128 operands for each
+\needlines{4}
+\item \texttt{standard\_opcode\_lengths} (array of \addtoindex{ubyte}) \\
+\addttindexx{standard\_opcode\_lengths}
+This array specifies the number of \addtoindex{LEB128} operands for each
 of the standard opcodes. The first element of the array
 corresponds to the opcode whose value is 1, and the last
 element corresponds to the opcode whose value 
-is opcode\_base - 1.
+is \texttt{opcode\_base - 1}.
 
-By increasing opcode\_base, and adding elements to this array,
+\textit{By increasing \texttt{opcode\_base}, and adding elements to this array,
+\addttindexx{opcode\_base}
 new standard opcodes can be added, while allowing consumers who
-do not know about these new opcodes to be able to skip them.
+do not know about these new opcodes to be able to skip them.}
 
-Codes for vendor specific extensions, if any, are described
-just like standard opcodes.
+\textit{Codes for vendor specific extensions, if any, are described
+just like standard opcodes.}
 
-\item include\_directories (sequence of path names) \\
-Entries in this sequence describe each path that was searched
+\needlines{3}
+\item \texttt{include\_directories} (sequence of path names) \\
+Entries 
+\addttindexx{include\_directories}
+in this sequence describe each path that was searched
 for included source files in this compilation. (The paths
 include those directories specified explicitly by the user for
 the compiler to search and those the compiler searches without
@@ -549,10 +618,15 @@ entries in order, beginning with 1. The current directory of
 the compilation is understood to be the zeroth entry and is
 not explicitly represented.
 
-\item  file\_names (sequence of file entries) \\
-Entries in this sequence describe source files that contribute
+\item  \texttt{file\_names} (sequence of file entries) \\
+Entries 
+\addtoindexx{file names}
+in 
+\addttindexx{file\_names}
+this sequence describe source files that contribute
 to the line number information for this compilation unit or is
-used in other contexts, such as in a declaration coordinate or
+used in other contexts, such as in a 
+\livelinki{chap:declarationcoordinates}{declaration coordinate}{declaration coordinates} or
 a macro file inclusion. Each entry consists of the following
 values:
 
@@ -562,18 +636,24 @@ values:
 path name of a source file. If the entry contains a file
 name or relative path name, the file is located relative
 to either the compilation directory (as specified by the
-\livelink{chap:DWATcompdir}{DW\-\_AT\-\_comp\-\_dir} attribute given in the compilation unit) or one
-of the directories listed in the include\_directories section.
+\livelink{chap:DWATcompdir}{DW\_AT\_comp\_dir} 
+attribute given in the compilation unit) or one
+of the directories listed in the 
+\addttindex{include\_directories} section.
 
-\item An unsigned LEB128 number representing the directory
-index of a directory in the include\_directories section.
+\item An unsigned LEB128\addtoindexx{LEB128!unsigned} 
+number representing the directory
+index of a directory in the 
+\addttindex{include\_directories} section.
 
 
-\item An unsigned LEB128 number representing the
+\item An unsigned LEB128\addtoindexx{LEB128!unsigned}
+number representing the
 (implementation\dash defined) time of last modification for
 the file, or 0 if not available.
 
-\item An unsigned LEB128 number representing the length in
+\item An unsigned LEB128\addtoindexx{LEB128!unsigned} 
+number representing the length in
 bytes of the file, or 0 if not available.  
 
 \end{itemize}
@@ -581,14 +661,16 @@ bytes of the file, or 0 if not available.
 The last entry is followed by a single null byte.
 
 The directory index represents an entry in the
-include\_directories section. The index is 0 if the file was
+\addttindex{include\_directories} section. 
+The index is 0 if the file was
 found in the current directory of the compilation, 1 if it
-was found in the first directory in the include\_directories
+was found in the first directory in the 
+\addttindex{include\_directories}
 section, and so on. The directory index is ignored for file
 names that represent full path names.
 
 The primary source file is described by an entry whose path
-name exactly matches that given in the \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+name exactly matches that given in the \livelink{chap:DWATname}{DW\_AT\_name} attribute
 in the compilation unit, and whose directory is understood
 to be given by the implicit entry with index 0.
 
@@ -598,7 +680,7 @@ instead of file names in the file register.
 
 \textit{A compiler may generate a single null byte for the file
 names field and define file names using the extended opcode
-\livelink{chap:DWLNEdefinefile}{DW\-\_LNE\-\_define\-\_file}.}
+\livelink{chap:DWLNEdefinefile}{DW\_LNE\_define\_file}.}
 
 
 \end{enumerate}
@@ -608,34 +690,36 @@ names field and define file names using the extended opcode
 As stated before, the goal of a line number program is to build
 a matrix representing one compilation unit, which may have
 produced multiple sequences of target machine instructions.
-Within a sequence, addresses (operation pointers) may only
+Within a sequence, addresses 
+\addtoindexx{operation pointer}
+(operation pointers) may only
 increase. (Line numbers may decrease in cases of pipeline
 scheduling or other optimization.)
 
 \subsubsection{Special Opcodes} 
 \label{chap:specialopcodes}
-Each ubyte special opcode has the following effect on the state machine:
+Each \addtoindex{ubyte} special opcode has the following effect on the state machine:
 
-\begin{enumerate}[1.]
+\begin{enumerate}[1. ]
 
-\item  Add a signed integer to the line register.
+\item  Add a signed integer to the \texttt{line} register.
 
-\item  Modify the operation pointer by incrementing the
-address and op\_index registers as described below.
+\item  Modify the \addtoindex{operation pointer} by incrementing the
+\texttt{address} and \addttindex{op\_index} registers as described below.
 
 \item  Append a row to the matrix using the current values
 of the state machine registers.
 
-\item  Set the basic\_block register to ``false.'' \addtoindexx{basic block}
-\item  Set the prologue\_end register to ``false.''
-\item  Set the epilogue\_begin register to ``false.''
-\item  Set the discriminator register to 0.
+\item  Set the \addttindex{basic\_block} register to \doublequote{false.} \addtoindexx{basic block}
+\item  Set the \addttindex{prologue\_end} register to \doublequote{false.}
+\item  Set the \addttindex{epilogue\_begin} register to \doublequote{false.}
+\item  Set the \addttindex{discriminator} register to 0.
 
 \end{enumerate}
 
 All of the special opcodes do those same seven things; they
 differ from one another only in what values they add to the
-line, address and op\_index registers.
+\texttt{line}, \texttt{address} and \addttindex{op\_index} registers.
 
 
 \textit{Instead of assigning a fixed meaning to each special opcode,
@@ -644,105 +728,113 @@ to configure the instruction set. There are two reasons
 for this.  First, although the opcode space available for
 special opcodes now ranges from 13 through 255, the lower
 bound may increase if one adds new standard opcodes. Thus, the
-opcode\_base field of the line number program header gives the
+\texttt{opcode\_base} field of the line number program header gives the
 value of the first special opcode. Second, the best choice of
 special\dash opcode meanings depends on the target architecture. For
 example, for a RISC machine where the compiler\dash generated code
 interleaves instructions from different lines to schedule
 the pipeline, it is important to be able to add a negative
-value to the line register to express the fact that a later
+value to the \texttt{line} register to express the fact that a later
 instruction may have been emitted for an earlier source
 line. For a machine where pipeline scheduling never occurs,
 it is advantageous to trade away the ability to decrease
-the line register (a standard opcode provides an alternate
+the \texttt{line} register (a standard opcode provides an alternate
 way to decrease the line number) in return for the ability
-to add larger positive values to the address register. To
+to add larger positive values to the \texttt{address} register. To
 permit this variety of strategies, the line number program
-header defines a line\_base field that specifies the minimum
+header defines a 
+\addttindex{line\_base}
+field that specifies the minimum
 value which a special opcode can add to the line register
-and a line\_range field that defines the range of values it
+and a 
+\addttindex{line\_range}
+field that defines the range of values it
 can add to the line register.}
 
 
 A special opcode value is chosen based on the amount that needs
-to be added to the line, address and op\_index registers. The
-maximum line increment for a special opcode is the value
-of the line\_base field in the header, plus the value of
-the line\_range field, minus 1 (line base + 
+to be added to the \texttt{line}, \texttt{address} and \addttindex{op\_index} registers.
+The maximum line increment for a special opcode is the value
+of the 
+\addttindex{line\_base}
+field in the header, plus the value of the 
+\addttindex{line\_range} field, minus 1 (line base + 
 line range - 1). 
 If the desired line increment is greater than the maximum
 line increment, a standard opcode must be used instead of a
-special opcode. The operation advance represents the number
-of operations to skip when advancing the operation pointer.
+special opcode. The \addtoindex{operation advance} represents the number
+of operations to skip when advancing the \addtoindex{operation pointer}.
 
 The special opcode is then calculated using the following formula:
-
-  opcode = ( \textit{desired line increment} - line\_base) +
-(line\_range * \textit{operation advance} ) + opcode\_base
-
+\begin{alltt}
+  opcode = 
+    (\textit{desired line increment} - \addttindex{line\_base}) +
+      (\addttindex{line\_range} * \textit{operation advance}) + \addttindex{opcode\_base}
+\end{alltt}
 If the resulting opcode is greater than 255, a standard opcode
 must be used instead.
 
-When maximum\_operations\_per\_instruction is 1, the operation
-advance is simply the address increment divided by the
-minimum\_instruction\_length.
+\textit{When \addttindex{maximum\_operations\_per\_instruction} is 1, 
+the operation advance is simply the address increment divided by the
+\addttindex{minimum\_instruction\_length}.}
 
-To decode a special opcode, subtract the opcode\_base from
+\needlines{6}
+To decode a special opcode, subtract the \addttindex{opcode\_base} from
 the opcode itself to give the \textit{adjusted opcode}. 
 The \textit{operation advance} 
 is the result of the adjusted opcode divided by the
-line\_range. The new address and op\_index values are given by
-\begin{myindentpara}{1cm}
-
-\textit{adjusted opcode} = opcode – opcode\_base
-
-\textit{operation advance} = \textit{adjusted opcode} / line\_range
-
-\begin{myindentpara}{1cm}
-new address =
-
-address +
-
-minimum\_instruction\_length *
-((op\_index + operation advance) / 
-maximum\_operations\_per\_instruction)
-\end{myindentpara}
-new op\_index =
-
-\begin{myindentpara}{1cm}
-(op\_index + operation advance) \% maximum\_operations\_per\_instruction
-\end{myindentpara}
-
-\end{myindentpara}
-
-\textit{When the maximum\_operations\_per\_instruction field is 1,
-op\_index is always 0 and these calculations simplify to those
-given for addresses in DWARF Version 3.}
-
-The amount to increment the line register is the line\_base plus
-the result of the adjusted opcode modulo the line\_range. That
+\texttt{line\_range}. The new \texttt{address} and 
+\addttindex{op\_index} values are given by
+\begin{alltt}
+  \textit{adjusted opcode} = opcode \dash opcode\_base
+  \textit{operation advance} = \textit{adjusted opcode} / line\_range
+
+  new address = address +
+    \addttindex{minimum\_instruction\_length} *
+      ((\addttindex{op\_index} + \addtoindex{operation advance}) / \addttindex{maximum\_operations\_per\_instruction})
+
+  new op\_index =
+    (\addttindex{op\_index} + \addtoindex{operation advance}) \% \addttindex{maximum\_operations\_per\_instruction}
+\end{alltt}
+
+\textit{When the \addttindex{maximum\_operations\_per\_instruction} field is 1,
+\texttt{op\_index} is always 0 and these calculations simplify to those
+given for addresses in 
+\addtoindex{DWARF Version 3}.}
+
+The amount to increment the line register is the 
+\addttindex{line\_base} plus
+the result of the 
+\textit{\addtoindex{adjusted opcode}} modulo the 
+\addttindex{line\_range}. That
 is,
 
-\begin{myindentpara}{1cm}
-line increment = line\_base + (adjusted opcode \% line\_range)
-\end{myindentpara}
-
-\textit{As an example, suppose that the opcode\_base is 13, line\_base
-is -3, line\_range is 12, minimum\_instruction\_length is 1
-and maximum\_operations\_per\_instruction is 1. This means that
+\begin{alltt}
+  line increment = \addttindex{line\_base} + (\textit{adjusted opcode} \% \addttindex{line\_range})
+\end{alltt}
+
+\textit{As an example, suppose that the opcode\_base is 13, 
+\addttindex{line\_base} is -3, 
+\addttindex{line\_range} is 12, 
+\addttindex{minimum\_instruction\_length} is 1
+and 
+\addttindex{maximum\_operations\_per\_instruction} is 1. 
+This means that
 we can use a special opcode whenever two successive rows in
 the matrix have source line numbers differing by any value
 within the range [-3, 8] and (because of the limited number
 of opcodes available) when the difference between addresses
 is within the range [0, 20], but not all line advances are
-available for the maximum operation advance (see below).}
+available for the maximum \addtoindex{operation advance} (see below).}
 
-\textit{The opcode mapping would be:}
-% FIXME: This should be a tabular or the like, not a verbatim
-\begin{verbatim}
-            \       Line advance
-   Operation \
-     Advance  \ -3  -2  -1   0   1   2   3   4   5   6   7   8
+\textit{The resulting opcode mapping is shown in
+Figure \refersec{fig:examplelinenumberspecialopcodemapping}.}
+
+\begin{figure}[ht]
+\begin{alltt}\textit{
+                        Line Advance
+   Operation  
+     Advance    -3  -2  -1   0   1   2   3   4   5   6   7   8
    ---------   -----------------------------------------------
            0    13  14  15  16  17  18  19  20  21  22  23  24
            1    25  26  27  28  29  30  31  32  33  34  35  36
@@ -765,12 +857,14 @@ available for the maximum operation advance (see below).}
           18   229 230 231 232 233 234 235 236 237 238 239 240 
           19   241 242 243 244 245 246 247 248 249 250 251 252
           20   253 254 255
-\end{verbatim}
-
+}\end{alltt}
+\caption{Example line number special opcode mapping}
+\label{fig:examplelinenumberspecialopcodemapping}
+\end{figure}
 
 \textit{There is no requirement that the expression 
-255 - line\_base + 1 be an integral multiple of
-line\_range. }
+255 - \addttindex{line\_base} + 1 be an integral multiple of
+\addttindex{line\_range}. }
 
 \subsubsection{Standard Opcodes}
 \label{chap:standardopcodes}
@@ -779,85 +873,100 @@ line\_range. }
 The standard opcodes, their applicable operands and the
 actions performed by these opcodes are as follows:
 
-\begin{enumerate}[1.]
+\begin{enumerate}[1. ]
 
-\item \textbf{DW\-\_LNS\-\_copy} \\
-The \livetarg{chap:DWLNScopy}{DW\-\_LNS\-\_copy} opcode takes no operands. It appends a row
+\item \textbf{DW\_LNS\_copy} \\
+The \livetarg{chap:DWLNScopy}{DW\_LNS\_copy} 
+opcode takes no operands. It appends a row
 to the matrix using the current values of the state machine
-registers. Then it sets the discriminator register to 0,
-and sets the basic\_block, prologue\_end and epilogue\_begin
-registers to ``false.''
-
-\item \textbf{DW\-\_LNS\-\_advance\-\_pc} \\
-The \livetarg{chap:DWLNSadvancepc}{DW\-\_LNS\-\_advance\-\_pc} opcode takes a single unsigned LEB128
-operand as the operation advance and modifies the address
-and op\_index registers as specified in 
+registers. Then it sets the \addttindex{discriminator} register to 0,
+and sets the \addttindex{basic\_block}, 
+\addttindex{prologue\_end} and 
+\addttindex{epilogue\_begin}
+registers to \doublequote{false.}
+
+\item \textbf{DW\_LNS\_advance\_pc} \\
+The \livetarg{chap:DWLNSadvancepc}{DW\_LNS\_advance\_pc} 
+opcode takes a single unsigned LEB128\addtoindexx{LEB128!unsigned}
+operand as the \addtoindex{operation advance} and modifies the \texttt{address}
+and \addttindex{op\_index} registers as specified in 
 Section \refersec{chap:specialopcodes}.
 
-\item \textbf{DW\-\_LNS\-\_advance\-\_line} \\
-The \livetarg{chap:DWLNSadvanceline}{DW\-\_LNS\-\_advance\-\_line} opcode takes a single signed LEB128
-operand and adds that value to the line register of the
+\item \textbf{DW\_LNS\_advance\_line} \\
+The \livetarg{chap:DWLNSadvanceline}{DW\_LNS\_advance\_line} 
+opcode takes a single signed LEB128\addtoindexx{LEB128!signed}
+operand and adds that value to the \texttt{line} register of the
 state machine.
 
-\item \textbf{DW\-\_LNS\-\_set\-\_file} \\ 
-The \livetarg{chap:DWLNSsetfile}{DW\-\_LNS\-\_set\-\_file} opcode takes a single
-unsigned LEB128 operand and stores it in the file register
+\needlines{4}
+\item \textbf{DW\_LNS\_set\_file} \\ 
+The \livetarg{chap:DWLNSsetfile}{DW\_LNS\_set\_file} opcode takes a single
+unsigned LEB128\addtoindexx{LEB128!unsigned} 
+operand and stores it in the \texttt{file} register
 of the state machine.
 
-\item \textbf{DW\-\_LNS\-\_set\-\_column} \\ 
-The \livetarg{chap:DWLNSsetcolumn}{DW\-\_LNS\-\_set\-\_column} opcode takes a
-single unsigned LEB128 operand and stores it in the column
+\needlines{4}
+\item \textbf{DW\_LNS\_set\_column} \\ 
+The \livetarg{chap:DWLNSsetcolumn}{DW\_LNS\_set\_column} opcode takes a
+single unsigned LEB128\addtoindexx{LEB128!unsigned} operand 
+and stores it in the \texttt{column}
 register of the state machine.
 
-\item \textbf{DW\-\_LNS\-\_negate\-\_stmt} \\
-The \livetarg{chap:DWLNSnegatestmt}{DW\-\_LNS\-\_negate\-\_stmt} opcode takes no
-operands. It sets the is\_stmt register of the state machine
+\needlines{4}
+\item \textbf{DW\_LNS\_negate\_stmt} \\
+The \livetarg{chap:DWLNSnegatestmt}{DW\_LNS\_negate\_stmt} opcode takes no
+operands. It sets the \addttindex{is\_stmt} register of the state machine
 to the logical negation of its current value.
 
-\item \textbf{DW\-\_LNS\-\_set\-\_basic\-\_block} \\
-The \livetarg{chap:DWLNSsetbasicblock}{DW\-\_LNS\-\_set\-\_basic\-\_block}
+\needlines{4}
+\item \textbf{DW\_LNS\_set\_basic\_block} \\
+The \livetarg{chap:DWLNSsetbasicblock}{DW\_LNS\_set\_basic\_block}
 opcode
 \addtoindexx{basic block}
 takes no operands. 
-It sets the basic\_block register of the
-state machine to ``true.''
+It sets the \addttindex{basic\_block} register of the
+state machine to \doublequote{true.}
 
 
 
-\item \textbf{DW\-\_LNS\-\_const\-\_add\-\_pc} \\
-The \livetarg{chap:DWLNSconstaddpc}{DW\-\_LNS\-\_const\-\_add\-\_pc} opcode takes
-no operands. It advances the address and op\_index registers
+\item \textbf{DW\_LNS\_const\_add\_pc} \\
+The \livetarg{chap:DWLNSconstaddpc}{DW\_LNS\_const\_add\_pc} opcode takes
+no operands. It advances the \texttt{address} and \addttindex{op\_index} registers
 by the increments corresponding to special opcode 255.
 
-\textit{When the line number program needs to advance the address
+\textit{When the line number program needs to advance the \texttt{address}
 by a small amount, it can use a single special opcode,
 which occupies a single byte. When it needs to advance the
-address by up to twice the range of the last special opcode,
-it can use \livelink{chap:DWLNSconstaddpc}{DW\-\_LNS\-\_const\-\_add\-\_pc} followed by a special opcode,
+\texttt{address} by up to twice the range of the last special opcode,
+it can use \livelink{chap:DWLNSconstaddpc}{DW\_LNS\_const\_add\_pc} followed by a special opcode,
 for a total of two bytes. Only if it needs to advance the
 address by more than twice that range will it need to use
-both \livelink{chap:DWLNSadvancepc}{DW\-\_LNS\-\_advance\-\_pc} and a special opcode, requiring three
+both \livelink{chap:DWLNSadvancepc}{DW\_LNS\_advance\_pc} and a special opcode, requiring three
 or more bytes.}
 
-\item \textbf{DW\-\_LNS\-\_fixed\-\_advance\-\_pc} \\ 
-The \livetarg{chap:DWLNSfixedadvancepc}{DW\-\_LNS\-\_fixed\-\_advance\-\_pc} opcode
-takes a single uhalf (unencoded) operand and adds it to the
-address register of the state machine and sets the op\_index
+\item \textbf{DW\_LNS\_fixed\_advance\_pc} \\ 
+The \livetarg{chap:DWLNSfixedadvancepc}{DW\_LNS\_fixed\_advance\_pc} opcode
+takes a single \addtoindex{uhalf} (unencoded) operand and adds it to the
+\texttt{address} register of the state machine and sets the \addttindex{op\_index}
 register to 0. This is the only standard opcode whose operand
 is \textbf{not} a variable length number. It also does 
 \textbf{not} multiply the
-operand by the minimum\_instruction\_length field of the header.
+operand by the \addttindex{minimum\_instruction\_length} 
+field of the header.
 
-\textit{Existing assemblers cannot emit \livelink{chap:DWLNSadvancepc}{DW\-\_LNS\-\_advance\-\_pc} or special
-opcodes because they cannot encode LEB128 numbers or judge when
+\textit{Existing assemblers cannot emit 
+\livelink{chap:DWLNSadvancepc}{DW\_LNS\_advance\_pc} or special
+opcodes because they cannot encode \addtoindex{LEB128} numbers or judge when
 the computation of a special opcode overflows and requires
-the use of \livelink{chap:DWLNSadvancepc}{DW\-\_LNS\-\_advance\-\_pc}. Such assemblers, however, can
-use \livelink{chap:DWLNSfixedadvancepc}{DW\-\_LNS\-\_fixed\-\_advance\-\_pc} instead, sacrificing compression.}
+the use of \livelink{chap:DWLNSadvancepc}{DW\_LNS\_advance\_pc}. Such assemblers, however, can
+use \livelink{chap:DWLNSfixedadvancepc}{DW\_LNS\_fixed\_advance\_pc} instead, sacrificing compression.}
 
-\item \textbf{DW\-\_LNS\-\_set\-\_prologue\-\_end} \\
-The \livetarg{chap:DWLNSsetprologueend}{DW\-\_LNS\-\_set\-\_prologue\-\_end}
-opcode takes no operands. It sets the prologue\_end register
-to ``true''.
+\needlines{6}
+\item \textbf{DW\_LNS\_set\_prologue\_end} \\
+The \livetarg{chap:DWLNSsetprologueend}{DW\_LNS\_set\_prologue\_end}
+opcode takes no operands. It sets the 
+\addttindex{prologue\_end} register
+to \doublequote{true.}
 
 \textit{When a breakpoint is set on entry to a function, it is
 generally desirable for execution to be suspended, not on the
@@ -873,16 +982,17 @@ the location(s) to use.}
 location; for example, the code might test for a special case
 and make a fast exit prior to setting up the frame.}
 
-\textit{Note that the function to which the prologue end applies cannot
+\textit{Note that the function to which the 
+\addtoindex{prologue end} applies cannot
 be directly determined from the line number information alone;
 it must be determined in combination with the subroutine
 information entries of the compilation (including inlined
 subroutines).}
 
 
-\item \textbf{DW\-\_LNS\-\_set\-\_epilogue\-\_begin} \\
-The \livetarg{chap:DWLNSsetepiloguebegin}{DW\-\_LNS\-\_set\-\_epilogue\-\_begin} opcode takes no operands. It
-sets the epilogue\_begin register to ``true''.
+\item \textbf{DW\_LNS\_set\_epilogue\_begin} \\
+The \livetarg{chap:DWLNSsetepiloguebegin}{DW\_LNS\_set\_epilogue\_begin} opcode takes no operands. It
+sets the \addttindex{epilogue\_begin} register to \doublequote{true.}
 
 \textit{When a breakpoint is set on the exit of a function or execution
 steps over the last executable statement of a function, it is
@@ -892,100 +1002,107 @@ local variables can still be examined). Debuggers generally
 cannot properly determine where this point is. This command
 allows a compiler to communicate the location(s) to use.}
 
-\textit{Note that the function to which the epilogue end applies cannot
+\textit{Note that the function to which the 
+\addtoindex{epilogue end} applies cannot
 be directly determined from the line number information alone;
 it must be determined in combination with the subroutine
 information entries of the compilation (including inlined
 subroutines).}
 
-\textit{In the case of a trivial function, both prologue end and
-epilogue begin may occur at the same address.}
+\textit{In the case of a trivial function, both 
+\addtoindex{prologue end} and
+\addtoindex{epilogue begin} may occur at the same address.}
 
-\item \textbf{DW\-\_LNS\-\_set\-\_isa} \\
-The \livetarg{chap:DWLNSsetisa}{DW\-\_LNS\-\_set\-\_isa} opcode takes a single
-unsigned LEB128 operand and stores that value in the isa
+\item \textbf{DW\_LNS\_set\_isa} \\
+The \livetarg{chap:DWLNSsetisa}{DW\_LNS\_set\_isa} opcode takes a single
+unsigned LEB128\addtoindexx{LEB128!unsigned} operand and stores that value in the 
+\addttindex{isa}
 register of the state machine.
 \end{enumerate}
 
-\subsubsection{ExtendedOpcodes}
+\needlines{8}
+\subsubsection{Extended Opcodes}
 \label{chap:extendedopcodes}
 
 The extended opcodes are as follows:
 
-\begin{enumerate}[1.]
+\begin{enumerate}[1. ]
 
-\item \textbf{DW\-\_LNE\-\_end\-\_sequence} \\
-The \livetarg{chap:DWLNEendsequence}{DW\-\_LNE\-\_end\-\_sequence} opcode takes no operands. It sets the
-end\_sequence register of the state machine to “true” and
+\item \textbf{DW\_LNE\_end\_sequence} \\
+The \livetarg{chap:DWLNEendsequence}{DW\_LNE\_end\_sequence} opcode takes no operands. It sets the
+\addttindex{end\_sequence}
+register of the state machine to \doublequote{true} and
 appends a row to the matrix using the current values of the
 state-machine registers. Then it resets the registers to the
 initial values specified above 
 (see Section \refersec{chap:statemachineregisters}). 
 Every line
-number program sequence must end with a \livelink{chap:DWLNEendsequence}{DW\-\_LNE\-\_end\-\_sequence}
+number program sequence must end with a \livelink{chap:DWLNEendsequence}{DW\_LNE\_end\_sequence}
 instruction which creates a row whose address is that of the
 byte after the last target machine instruction of the sequence.
 
-\item \textbf{DW\-\_LNE\-\_set\-\_address} \\
-The \livetarg{chap:DWLNEsetaddress}{DW\-\_LNE\-\_set\-\_address} opcode takes a single relocatable
+\needlines{5}
+\item \textbf{DW\_LNE\_set\_address} \\
+The \livetarg{chap:DWLNEsetaddress}{DW\_LNE\_set\_address} opcode takes a single relocatable
 address as an operand. The size of the operand is the size
-of an address on the target machine. It sets the address
+of an address on the target machine. It sets the \texttt{address}
 register to the value given by the relocatable address and
-sets the op\_index register to 0.
+sets the \addttindex{op\_index} register to 0.
 
 \textit{All of the other line number program opcodes that
-affect the address register add a delta to it. This instruction
+affect the \texttt{address} register add a delta to it. This instruction
 stores a relocatable value into it instead.}
 
+\needlines{4}
+\item \textbf{DW\_LNE\_define\_file} \\
 
-\item \textbf{DW\-\_LNE\-\_define\-\_file} \\
-
-The \livetarg{chap:DWLNEdefinefile}{DW\-\_LNE\-\_define\-\_file} opcode takes four operands:
-
-\begin{enumerate}[1.]
+The \livetarg{chap:DWLNEdefinefile}{DW\_LNE\_define\_file} opcode takes four operands:
+\begin{enumerate}[1. ]
 
 \item A null\dash terminated string containing the full or relative
 path name of a source file. If the entry contains a file
 name or a relative path name, the file is located relative
 to either the compilation directory (as specified by the
-\livelink{chap:DWATcompdir}{DW\-\_AT\-\_comp\-\_dir} attribute given in the compilation unit)
-or one of the directories in the include\_directories section.
+\livelink{chap:DWATcompdir}{DW\_AT\_comp\_dir} attribute given in the compilation unit)
+or one of the directories in the 
+\addttindex{include\_directories} section.
 
-\item An unsigned LEB128 number representing the directory index
+\item An unsigned LEB128\addtoindexx{LEB128!unsigned} 
+number representing the directory index
 of the directory in which the file was found.  
 
-\item An unsigned
-LEB128 number representing the time of last modification
+\item An unsigned LEB128\addtoindexx{LEB128!unsigned} 
+number representing the time of last modification
 of the file, or 0 if not available.  
 
-\item An unsigned LEB128
+\item An unsigned LEB128\addtoindexx{LEB128!unsigned}
 number representing the length in bytes of the file, or 0 if
 not available.
 \end{enumerate}
 
 The directory index represents an entry in the
-include\_directories section of the line number program
+\addttindex{include\_directories} section of the line number program
 header. The index is 0 if the file was found in the current
 directory of the compilation, 1 if it was found in the first
-directory in the include\_directories section, and so on. The
+directory in the \addttindex{include\_directories} section,
+and so on. The
 directory index is ignored for file names that represent full
 path names.
 
 The primary source file is described by an entry whose path
-name exactly matches that given in the \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+name exactly matches that given in the \livelink{chap:DWATname}{DW\_AT\_name} attribute
 in the compilation unit, and whose directory index is 0. The
 files are numbered, starting at 1, in the order in which they
 appear; the names in the header come before names defined by
-the \livelink{chap:DWLNEdefinefile}{DW\-\_LNE\-\_define\-\_file} instruction. These numbers are used
+the \livelink{chap:DWLNEdefinefile}{DW\_LNE\_define\_file} instruction. These numbers are used
 in the file register of the state machine.
 
-\item \textbf{DW\-\_LNE\-\_set\-\_discriminator} \\
-The \livetarg{chap:DWLNEsetdiscriminator}{DW\-\_LNE\-\_set\-\_discriminator}
+\item \textbf{DW\_LNE\_set\_discriminator} \\
+The \livetarg{chap:DWLNEsetdiscriminator}{DW\_LNE\_set\_discriminator}
 opcode takes a single
-parameter, an unsigned LEB128 integer. It sets the
-discriminator register to the new value.
-
-
+parameter, an unsigned LEB128\addtoindexx{LEB128!unsigned} 
+integer. It sets the
+\addttindex{discriminator} register to the new value.
 
 \end{enumerate}
 
@@ -994,7 +1111,10 @@ gives some sample line number programs.}
 
 \section{Macro Information}
 \label{chap:macroinformation}
-\textit{Some languages, such as C and C++, provide a way to replace
+\textit{Some languages, such as 
+\addtoindex{C} and 
+\addtoindex{C++}, provide a way to replace
+\addtoindexx{macro information}
 text in the source program with macros defined either in the
 source file itself, or in another file included by the source
 file.  Because these macros are not themselves defined in the
@@ -1005,12 +1125,14 @@ the macro definition has been expanded, rather than as the
 programmer wrote it. The macro information table provides a way
 of preserving the original source in the debugging information.}
 
-As described in Section 3.1.1, the macro information for a
+As described in 
+Section \refersec{chap:normalandpartialcompilationunitentries},
+the macro information for a
 given compilation unit is represented in the 
-\addtoindex{.debug\_macinfo}
+\dotdebugmacinfo{}
 section of an object file. The macro information for each
-compilation unit is represented as a series of “macinfo”
-entries. Each macinfo entry consists of a “type code” and
+compilation unit is represented as a series of \doublequote{macinfo}
+entries. Each macinfo entry consists of a \doublequote{type code} and
 up to two additional operands. The series of entries for a
 given compilation unit ends with an entry containing a type
 code of 0.
@@ -1018,41 +1140,42 @@ code of 0.
 \subsection{Macinfo Types}
 \label{chap:macinfotypes}
 
-The valid macinfo types are as follows:
+The valid \addtoindex{macinfo types} are as follows:
 
 \begin{tabular}{ll}
-\livelink{chap:DWMACINFOdefine}{DW\-\_MACINFO\-\_define} 
-&A macro definition.\\
-\livelink{chap:DWMACINFOundef}{DW\-\_MACINFO\-\_undef}
-&A macro undefinition.\\
-\livelink{chap:DWMACINFOstartfile}{DW\-\_MACINFO\-\_start\-\_file}
-&The start of a new source file inclusion.\\
-\livelink{chap:DWMACINFOendfile}{DW\-\_MACINFO\-\_end\-\_file}
-&The end of the current source file inclusion.\\
-\livelink{chap:DWMACINFOvendorext}{DW\-\_MACINFO\-\_vendor\-\_ext}
-& Vendor specific macro information directives.\\
+\livelink{chap:DWMACINFOdefine}{DW\_MACINFO\_define} 
+&A macro definition\\
+\livelink{chap:DWMACINFOundef}{DW\_MACINFO\_undef}
+&A macro undefinition\\
+\livelink{chap:DWMACINFOstartfile}{DW\_MACINFO\_start\_file}
+&The start of a new source file inclusion\\
+\livelink{chap:DWMACINFOendfile}{DW\_MACINFO\_end\_file}
+&The end of the current source file inclusion\\
+\livelink{chap:DWMACINFOvendorext}{DW\_MACINFO\_vendor\_ext}
+& Vendor specific macro information directives\\
 \end{tabular}
 
 \subsubsection{Define and Undefine Entries}
 \label{chap:defineandundefineentries}
 
 All 
-\livetarg{chap:DWMACINFOdefine}{DW\-\_MACINFO\-\_define} and 
-\livetarg{chap:DWMACINFOundef}{DW\-\_MACINFO\-\_undef} entries have two
+\livetarg{chap:DWMACINFOdefine}{DW\_MACINFO\_define} and 
+\livetarg{chap:DWMACINFOundef}{DW\_MACINFO\_undef} entries have two
 operands. The first operand encodes the line number of the
 source line on which the relevant defining or undefining
 macro directives appeared.
 
 The second operand consists of a null-terminated character
 string. In the case of a 
-\livelink{chap:DWMACINFOundef}{DW\-\_MACINFO\-\_undef} entry, the value
+\livelink{chap:DWMACINFOundef}{DW\_MACINFO\_undef} entry, the value
 of this string will be simply the name of the pre- processor
 symbol that was undefined at the indicated source line.
 
-In the case of a \livelink{chap:DWMACINFOdefine}{DW\-\_MACINFO\-\_define} entry, the value of this
+In the case of a \livelink{chap:DWMACINFOdefine}{DW\_MACINFO\_define} entry, the value of this
 string will be the name of the macro symbol that was defined
-at the indicated source line, followed immediately by the macro
-formal parameter list including the surrounding parentheses (in
+at the indicated source line, followed immediately by the 
+\addtoindex{macro formal parameter list}
+including the surrounding parentheses (in
 the case of a function-like macro) followed by the definition
 string for the macro. If there is no formal parameter list,
 then the name of the defined macro is followed directly by
@@ -1067,7 +1190,7 @@ are, however, separated by commas.) Also, exactly one space
 character should separate the right parenthesis that terminates
 the formal parameter list and the following definition string.
 
-In the case of a ``normal'' (i.e. non-function-like) macro
+In the case of a \doublequote{normal} (i.e. non-function-like) macro
 definition, exactly one space character should separate the
 name of the defined macro from the following definition text.
 
@@ -1075,7 +1198,7 @@ name of the defined macro from the following definition text.
 
 \subsubsection{Start File Entries}
 \label{chap:startfileentries}
-Each \livetarg{chap:DWMACINFOstartfile}{DW\-\_MACINFO\-\_start\-\_file} entry also has two operands. The
+Each \livetarg{chap:DWMACINFOstartfile}{DW\_MACINFO\_start\_file} entry also has two operands. The
 first operand encodes the line number of the source line on
 which the inclusion macro directive occurred.
 
@@ -1087,27 +1210,27 @@ the inclusion directive on the indicated source line.
 
 \subsubsection{End File Entries}
 \label{chap:endfileentries}
-A \livetarg{chap:DWMACINFOendfile}{DW\-\_MACINFO\-\_end\-\_file} entry has no operands. The presence of
+A \livetarg{chap:DWMACINFOendfile}{DW\_MACINFO\_end\_file} entry has no operands. The presence of
 the entry marks the end of the current source file inclusion.
 
 \subsubsection{Vendor Extension Entries}
 \label{chap:vendorextensionentries}
-A \livetarg{chap:DWMACINFOvendorext}{DW\-\_MACINFO\-\_vendor\-\_ext} entry has two operands. The first
+A \livetarg{chap:DWMACINFOvendorext}{DW\_MACINFO\_vendor\_ext} entry has two operands. The first
 is a constant. The second is a null-terminated character
 string. The meaning and/or significance of these operands is
 intentionally left undefined by this specification.
 
 \textit{A consumer must be able to totally ignore all
-\livelink{chap:DWMACINFOvendorext}{DW\-\_MACINFO\-\_vendor\-\_ext} entries that it does not understand
+\livelink{chap:DWMACINFOvendorext}{DW\_MACINFO\_vendor\_ext} entries that it does not understand
 (see Section \refersec{datarep:vendorextensibility}).}
 
 
 \subsection{Base Source Entries} 
 \label{chap:basesourceentries}
 
-A producer shall generate \livelink{chap:DWMACINFOstartfile}{DW\-\_MACINFO\-\_start\-\_file} and
-\livelink{chap:DWMACINFOendfile}{DW\-\_MACINFO\-\_end\-\_file} entries for the source file submitted to
-the compiler for compilation. This \livelink{chap:DWMACINFOstartfile}{DW\-\_MACINFO\-\_start\-\_file} entry
+A producer shall generate \livelink{chap:DWMACINFOstartfile}{DW\_MACINFO\_start\_file} and
+\livelink{chap:DWMACINFOendfile}{DW\_MACINFO\_end\_file} entries for the source file submitted to
+the compiler for compilation. This \livelink{chap:DWMACINFOstartfile}{DW\_MACINFO\_start\_file} entry
 has the value 0 in its line number operand and references
 the file entry in the line number information table for the
 primary source file.
@@ -1116,28 +1239,28 @@ primary source file.
 \subsection{Macinfo Entries For Command Line Options}
 \label{chap:macinfoentriesforcommandlineoptions}
 
-In addition to producing \livelink{chap:DWMACINFOdefine}{DW\-\_MACINFO\-\_define} and \livelink{chap:DWMACINFOundef}{DW\-\_MACINFO\-\_undef}
+In addition to producing \livelink{chap:DWMACINFOdefine}{DW\_MACINFO\_define} and \livelink{chap:DWMACINFOundef}{DW\_MACINFO\_undef}
 entries for each of the define and undefine directives
 processed during compilation, the DWARF producer should
-generate a \livelink{chap:DWMACINFOdefine}{DW\-\_MACINFO\-\_define} or \livelink{chap:DWMACINFOundef}{DW\-\_MACINFO\-\_undef} entry for
+generate a \livelink{chap:DWMACINFOdefine}{DW\_MACINFO\_define} or \livelink{chap:DWMACINFOundef}{DW\_MACINFO\_undef} entry for
 each pre-processor symbol which is defined or undefined by
 some means other than via a define or undefine directive
 within the compiled source text. In particular, pre-processor
 symbol definitions and un- definitions which occur as a
 result of command line options (when invoking the compiler)
-should be represented by their own \livelink{chap:DWMACINFOdefine}{DW\-\_MACINFO\-\_define} and
-\livelink{chap:DWMACINFOundef}{DW\-\_MACINFO\-\_undef} entries.
+should be represented by their own \livelink{chap:DWMACINFOdefine}{DW\_MACINFO\_define} and
+\livelink{chap:DWMACINFOundef}{DW\_MACINFO\_undef} entries.
 
-All such \livelink{chap:DWMACINFOdefine}{DW\-\_MACINFO\-\_define} and \livelink{chap:DWMACINFOundef}{DW\-\_MACINFO\-\_undef} entries
+All such \livelink{chap:DWMACINFOdefine}{DW\_MACINFO\_define} and \livelink{chap:DWMACINFOundef}{DW\_MACINFO\_undef} entries
 representing compilation options should appear before the
-first \livelink{chap:DWMACINFOstartfile}{DW\-\_MACINFO\-\_start\-\_file} entry for that compilation unit
+first \livelink{chap:DWMACINFOstartfile}{DW\_MACINFO\_start\_file} entry for that compilation unit
 and should encode the value 0 in their line number operands.
 
 
 \subsection{General rules and restrictions}
 \label{chap:generalrulesandrestrictions}
 
-All macinfo entries within a \addtoindex{.debug\_macinfo}
+All macinfo entries within a \dotdebugmacinfo{}
 section for a
 given compilation unit appear in the same order in which the
 directives were processed by the compiler.
@@ -1154,13 +1277,10 @@ to any definitions or undefinitions given explicitly by the
 user on the command line.
 
 
-
+\needlines{6}
 \section{Call Frame Information}
 \label{chap:callframeinformation}
 
-
-
-
 \textit{Debuggers often need to be able to view and modify the state of any subroutine activation that is
 \addtoindexx{activation!call frame}
 on the call stack. An activation consists of:}
@@ -1173,7 +1293,7 @@ is a place where a subroutine made a call or was interrupted
 by an asynchronous event (e.g. a signal).}
 
 \item \textit{An area of memory that is allocated on a stack called a
-``call frame.'' The call frame is identified by an address
+\doublequote{call frame.} The call frame is identified by an address
 on the stack. We refer to this address as the Canonical
 Frame Address or CFA. Typically, the CFA is defined to be the
 value of the stack pointer at the call site in the previous
@@ -1190,25 +1310,27 @@ across a call. If a callee wishes to use such a register, it
 saves the value that the register had at entry time in its call
 frame and restores it on exit. The code that allocates space
 on the call frame stack and performs the save operation is
-called the subroutine’s prologue, and the code that performs
+called the subroutine\textquoteright s \addtoindex{prologue}, and the code that performs
 the restore operation and deallocates the frame is called its
-epilogue. Typically, the prologue code is physically at the
-beginning of a subroutine and the epilogue code is at the end.}
+\addtoindex{epilogue}. Typically, the 
+\addtoindex{prologue} code is physically at the
+beginning of a subroutine and the 
+\addtoindex{epilogue} code is at the end.}
 
 \textit{To be able to view or modify an activation that is not
 on the top of the call frame stack, the debugger must
-``virtually unwind'' the stack of activations until
+\doublequote{virtually unwind} the stack of activations until
 it finds the activation of interest.  A debugger unwinds
 a stack in steps. Starting with the current activation it
 virtually restores any registers that were preserved by the
-current activation and computes the predecessors CFA and
+current activation and computes the predecessor\textquoteright s CFA and
 code location. This has the logical effect of returning from
 the current subroutine to its predecessor. We say that the
 debugger virtually unwinds the stack because the actual state
 of the target process is unchanged.}
 
 \textit{The unwinding operation needs to know where registers are
-saved and how to compute the predecessors CFA and code
+saved and how to compute the predecessor\textquoteright s CFA and code
 location. When considering an architecture-independent way
 of encoding this information one has to consider a number of
 special things.}
@@ -1216,10 +1338,14 @@ special things.}
 
 \begin{itemize} % bullet list
 
-\item \textit{Prologue and epilogue code is not always in 
-distinct block
+\item \textit{Prologue 
+\addtoindexx{prologue}
+and 
+\addtoindex{epilogue} code is not always in 
+distinct \nolink{blocks}
 at the beginning and end of a subroutine. It is common
-to duplicate the epilogue code at the site of each return
+to duplicate the \addtoindex{epilogue} code 
+at the site of each return
 from the code. Sometimes a compiler breaks up the register
 save/unsave operations and moves them into the body of the
 subroutine to just where they are needed.}
@@ -1230,7 +1356,9 @@ frame. Sometimes they use a frame pointer register, sometimes
 not.}
 
 \item \textit{The algorithm to compute CFA changes as you progress through
-the prologue and epilogue code. (By definition, the CFA value
+the \addtoindex{prologue} 
+and \addtoindex{epilogue code}. 
+(By definition, the CFA value
 does not change.)}
 
 \item \textit{Some subroutines have no call frame.}
@@ -1263,7 +1391,7 @@ registers during their lifetimes. This basis must be augmented
 on some machines with specific information that is defined by
 an architecture specific ABI authoring committee, a hardware
 vendor, or a compiler producer. The body defining a specific
-augmentation is referred to below as the ``augmenter.''
+augmentation is referred to below as the \doublequote{augmenter.}
 
 Abstractly, this mechanism describes a very large table that
 has the following structure:
@@ -1297,10 +1425,10 @@ contain rules that describe whether a given register has been
 saved and the rule to find the value for the register in the
 previous frame.
 
+\needlines{4}
 The register rules are:
 
-
-\begin{tabular}{lp{8cm}}
+\begin{longtable}{lp{8cm}}
 undefined 
 &A register that has this rule has no recoverable value in the previous frame.
 (By convention, it is not preserved by a callee.) \\
@@ -1323,16 +1451,16 @@ in another register numbered R.\\
 
 expression(E)
 &The previous value of this register is located at the address produced by
-executing the DWARF expression E.\\
+executing the DWARF expression E (see Section \refersec{chap:dwarfexpressions}).\\
 
 val\_expression(E) 
 &The previous value of this register is the value produced by executing the
-DWARF expression E.\\
+DWARF expression E (see Section \refersec{chap:dwarfexpressions}).\\
 
 architectural
 &The rule is defined externally to this specification by the augmenter.\\
 
-\end{tabular}
+\end{longtable}
 
 \textit{This table would be extremely large if actually constructed
 as described. Most of the entries at any point in the table
@@ -1343,11 +1471,14 @@ the program.}
 
 The virtual unwind information is encoded in a self-contained
 section called 
-\addtoindex{.debug\_frame}.  Entries in a 
-\addtoindex{.debug\_frame} section
+\dotdebugframe{}.  Entries in a 
+\dotdebugframe{} section
 are aligned on a multiple of the address size relative to
 the start of the section and come in two forms: a Common
-Information Entry (CIE) and a Frame Description Entry (FDE).
+\addtoindexx{common information entry}
+Information Entry (CIE) and a 
+\addtoindexx{frame description entry}
+Frame Description Entry (FDE).
 
 \textit{If the range of code addresses for a function is not
 contiguous, there may be multiple CIEs and FDEs corresponding
@@ -1356,29 +1487,28 @@ to the parts of that function.}
 
 A Common Information Entry holds information that is shared
 among many Frame Description Entries. There is at least one
-CIE in every non-empty \addtoindex{.debug\_frame} section. A CIE contains
+CIE in every non-empty \dotdebugframe{} section. A CIE contains
 the following fields, in order:
-
-\begin{enumerate}[1.]
-\item length (initial length)  \\
+\begin{enumerate}[1. ]
+\item \texttt{length} (\livelink{datarep:initiallengthvalues}{initial length})  \\
 A constant that gives the number of bytes of the CIE structure,
 not including the length field itself 
 (see Section \refersec{datarep:initiallengthvalues}). 
 The
-size of the length field plus the value of length must be an
+size of the \texttt{length} field plus the value of \texttt{length} must be an
 integral multiple of the address size.
 
-\item  CIE\_id (4 or 8 bytes, see Section \refersec{datarep:32bitand64bitdwarfformats}) \\
+\item  \texttt{CIE\_id} (4 or 8 bytes, see Section \refersec{datarep:32bitand64bitdwarfformats}) \\
 A constant that is used to distinguish CIEs from FDEs.
 
-\item  version (ubyte) \\
-A version number 
+\item  \texttt{version} (\addtoindex{ubyte}) \\
+A version number\addtoindexx{version number!call frame information} 
 (see Section \refersec{datarep:callframeinformation}). 
 This number is specific to the call frame information
 and is independent of the DWARF version number.
 
-
-\item  augmentation (UTF\dash 8 string) \\
+\needlines{8}
+\item  \texttt{augmentation} (\addtoindex{UTF\dash 8} string) \\
 A null\dash terminated UTF\dash 8 string that identifies the augmentation
 to this CIE or to the FDEs that use it. If a reader encounters
 an augmentation string that is unexpected, then only the
@@ -1387,36 +1517,39 @@ following fields can be read:
 
 \begin{itemize}
 
-\item CIE: length, CIE\_id, version, augmentation
+\item CIE: \texttt{length, CIE\_id, version, augmentation}
 
-\item FDE: length, CIE\_pointer, initial\_location, address\_range
+\item FDE: \texttt{length, CIE\_pointer, initial\_location, address\_range}
 
 \end{itemize}
 If there is no augmentation, this value is a zero byte.
 
+\needlines{5}
 \textit{The augmentation string allows users to indicate that there
 is additional target\dash specific information in the CIE or FDE
 which is needed to unwind a stack frame. For example, this
 might be information about dynamically allocated data which
 needs to be freed on exit from the routine.}
 
-\textit{Because the \addtoindex{.debug\_frame} section is useful independently of
-any \addtoindex{.debug\_info} section, the augmentation string always uses
+\textit{Because the \dotdebugframe{} section is useful independently of
+any \dotdebuginfo{} section, the augmentation string always uses
 UTF\dash 8 encoding.}
 
-\item  address\_size (ubyte) \\
+\item  \texttt{address\_size} (\addtoindex{ubyte}) \\
 The size of a target address
-\addtoindexx{address\_size}
+\addttindexx{address\_size}
 in this CIE and any FDEs that
 use it, in bytes. If a compilation unit exists for this frame,
 its address size must match the address size here.
 
-\item  segment\_size (ubyte) \\
-The size of a segment selector in this CIE and any FDEs that
+\item  \texttt{segment\_size} (\addtoindex{ubyte}) \\
+The \addttindexx{segment\_size}
+size of a segment selector in this CIE and any FDEs that
 use it, in bytes.
 
-\item  \addtoindex{code\_alignment\_factor} (unsigned LEB128) \\
-\addtoindex{code alignment factor}
+\item  \addttindex{code\_alignment\_factor} (unsigned LEB128) 
+\addtoindexx{LEB128!unsigned}\addtoindexx{unsigned LEB128|see{LEB128, unsigned}}
+\addtoindexx{code alignment factor} \\
 A 
 \addtoindexx{\textless caf\textgreater|see{code alignment factor}}
 constant that is factored out of all advance location
@@ -1424,66 +1557,78 @@ instructions (see
 Section \refersec{chap:rowcreationinstructions}).
 
 
-\item  \addtoindex{data\_alignment\_factor} (signed LEB128) \\
+\item  \addttindex{data\_alignment\_factor} (signed LEB128)
+\addtoindexx{LEB128!signed}\addtoindexx{signed LEB128|see{LEB128, signed}} \\
 \addtoindexx{data alignment factor}
 A 
 \addtoindexx{\textless daf\textgreater|see{data alignment factor}}
 constant that is factored out of certain offset instructions
-(see below). The resulting value is  \textit{(operand *
-data\_alignment\_factor)}.
+(see below). The resulting value is  \textit{(operand} *
+\texttt{data\_alignment\_factor}).
 
-\item  return\_address\_register (unsigned LEB128) \\
+\item  \texttt{return\_address\_register} (unsigned LEB128)\addtoindexx{LEB128!unsigned} \\
 An unsigned LEB128 constant that indicates which column in the
 rule table represents the return address of the function. Note
 that this column might not correspond to an actual machine
 register.
 
-\item initial\_instructions (array of ubyte) \\
+\item \texttt{initial\_instructions} (array of \addtoindex{ubyte}) \\
 A sequence of rules that are interpreted to create the initial
-setting of each column in the table.  The default rule for
+setting of each column in the table.  
+
+The default rule for
 all columns before interpretation of the initial instructions
 is the undefined rule. However, an ABI authoring body or a
 compilation system authoring body may specify an alternate
 default value for any or all columns.
 
-\item padding (array of ubyte) \\
-Enough \livelink{chap:DWCFAnop}{DW\-\_CFA\-\_nop} instructions to make the size of this entry
+\item \texttt{padding} (array of \addtoindex{ubyte}) \\
+Enough \livelink{chap:DWCFAnop}{DW\_CFA\_nop} instructions to make the size of this entry
 match the length value above.
 \end{enumerate}
 
+\needlines{5}
 An FDE contains the following fields, in order:
-
-\begin{enumerate}[1.]
-\item length (initial length)  \\
-
+\begin{enumerate}[1. ]
+\item \texttt{length} (\livelink{datarep:initiallengthvalues}{initial length})  \\
 A constant that gives the number of bytes of the header and
 instruction stream for this function, not including the length
 field itself 
-(see Section  \refersec{datarep:initiallengthvalues}). 
-The size of the length field
+(see Section \refersec{datarep:initiallengthvalues}). 
+The size of the \texttt{length} field
 plus the value of length must be an integral multiple of the
 address size.
 
 \item   CIE\_pointer (4 or 8 bytes, see Section \refersec{datarep:32bitand64bitdwarfformats}) \\
-A constant offset into the \addtoindex{.debug\_frame}
+A constant 
+\addtoindexx{section offset!in FDE header}
+offset into the \dotdebugframe{}
 section that denotes
 the CIE that is associated with this FDE.
 
-\item  initial\_location (segment selector and target address) \\
-The address of the first location associated with this table
-entry. If the segment\_size field of this FDE's CIE is non-zero,
+\needlines{4}
+\item  \texttt{initial\_location} (segment selector and target address) \\
+The 
+\addttindexx{initial\_location}
+address of the first location associated with this table
+entry. 
+If the \addttindex{segment\_size} field of this FDE's CIE is non-zero,
 the initial location is preceded by a segment selector of
 the given length.
 
-\item  address\_range (target address) \\
-The number of bytes of program instructions described by this entry.
+\item  \texttt{address\_range} (target address) \\
+The 
+\addttindexx{address\_range}
+number 
+\addtoindexx{target address}
+of bytes of program instructions described by this entry.
 
-\item instructions (array of ubyte) \\
+\item \texttt{instructions} (array of \addtoindex{ubyte}) \\
 A sequence of table defining instructions that are described below.
 
-\item 6. padding (array of ubyte) \\
-Enough \livelink{chap:DWCFAnop}{DW\-\_CFA\-\_nop} instructions to make the size of this
-entry match the length value above.
+\item \texttt{padding} (array of \addtoindex{ubyte}) \\
+Enough \livelink{chap:DWCFAnop}{DW\_CFA\_nop} instructions 
+to make the size of this entry match the length value above.
 \end{enumerate}
 
 \subsection{Call Frame Instructions}
@@ -1496,6 +1641,7 @@ opcode
 The instructions are defined in
 the following sections.
 
+\needlines{8}
 Some call frame instructions have operands that are encoded
 as DWARF expressions 
 (see Section \refersec{chap:generaloperations}). 
@@ -1504,94 +1650,101 @@ operators cannot be used in such operands:
 
 
 \begin{itemize}
-\item \livelink{chap:DWOPcall2}{DW\-\_OP\-\_call2}, \livelink{chap:DWOPcall4}{DW\-\_OP\-\_call4} 
-and \livelink{chap:DWOPcallref}{DW\-\_OP\-\_call\-\_ref} operators
-are not meaningful in an operand of these instructions
-because there is no mapping from call frame information to
-any corresponding debugging compilation unit information,
-thus there is no way to interpret the call offset.
-
-\item \livelink{chap:DWOPpushobjectaddress}{DW\-\_OP\-\_push\-\_object\-\_address} is not meaningful in an operand
+\item \livelink{chap:DWOPcall2}{DW\_OP\_call2}, \livelink{chap:DWOPcall4}{DW\_OP\_call4} 
+and \livelink{chap:DWOPcallref}{DW\_OP\_call\_ref} operators
+are allowed the call frame information must not depend on other
+debug sections.
+
+\needlines{5}
+\item \livelink{chap:DWOPpushobjectaddress}{DW\_OP\_push\_object\_address} is not meaningful in an operand
 of these instructions because there is no object context to
 provide a value to push.
 
-\item \livelink{chap:DWOPcallframecfa}{DW\-\_OP\-\_call\-\_frame\-\_cfa} is not meaningful in an operand of
+\item \livelink{chap:DWOPcallframecfa}{DW\_OP\_call\_frame\_cfa} is not meaningful in an operand of
 these instructions because its use would be circular.
 \end{itemize}
 
 \textit{Call frame instructions to which these restrictions apply
-include \livelink{chap:DWCFAdefcfaexpression}{DW\-\_CFA\-\_def\-\_cfa\-\_expression}, \livelink{chap:DWCFAexpression}{DW\-\_CFA\-\_expression}
-and \livelink{chap:DWCFAvalexpression}{DW\-\_CFA\-\_val\-\_expression}.}
+include \livelink{chap:DWCFAdefcfaexpression}{DW\_CFA\_def\_cfa\_expression}, \livelink{chap:DWCFAexpression}{DW\_CFA\_expression}
+and \livelink{chap:DWCFAvalexpression}{DW\_CFA\_val\_expression}.}
 
 \subsubsection{Row Creation Instructions}
 \label{chap:rowcreationinstructions}
+\begin{enumerate}[1. ]
 
-\begin{enumerate}[1.]
-
-\item \textbf{DW\-\_CFA\-\_set\-\_loc} \\
-The \livetarg{chap:DWCFAsetloc}{DW\-\_CFA\-\_set\-\_loc} instruction takes a single operand that
+\item \textbf{DW\_CFA\_set\_loc} \\
+The \livetarg{chap:DWCFAsetloc}{DW\_CFA\_set\_loc} instruction 
+takes a single operand that
 represents a target address. The required action is to create a
 new table row using the specified address as the location. All
 other values in the new row are initially identical to the
 current row. The new location value is always greater than
-the current one. If the segment\_size field of this FDE's CIE
-is non- zero, the initial location is preceded by a segment
+the current one. 
+If the \addttindex{segment\_size} field of this FDE's 
+\addtoindex{CIE}
+is non\dash zero, the initial location is preceded by a segment
 selector of the given length.
 
 
-\item \textbf{DW\-\_CFA\-\_advance\-\_loc} \\
-The \livetarg{chap:DWCFAadvanceloc}{DW\-\_CFA\-\_advanceloc} instruction takes a single operand (encoded
+\item \textbf{DW\_CFA\_advance\_loc} \\
+The \livetarg{chap:DWCFAadvanceloc}{DW\_CFA\_advance\_loc} instruction takes a single operand (encoded
 with the opcode) that represents a constant delta. The required
 action is to create a new table row with a location value that
-is computed by taking the current entrys location value
+is computed by taking the current entry\textquoteright s location value
 and adding the value of 
-\textit{delta * \addtoindex{code\_alignment\_factor}}. 
-All
-other values in the new row are initially identical to the
+\textit{delta} * \addttindex{code\_alignment\_factor}. 
+All other values in the new row are initially identical to the
 current row
 
-\item \textbf{DW\-\_CFA\-\_advance\-\_loc1} \\
-The \livetarg{chap:DWCFAadvanceloc1}{DW\-\_CFA\-\_advance\-\_loc1} instruction takes a single ubyte
+\item \textbf{DW\_CFA\_advance\_loc1} \\
+The \livetarg{chap:DWCFAadvanceloc1}{DW\_CFA\_advance\_loc1} instruction takes a single \addtoindex{ubyte}
 operand that represents a constant delta. This instruction
-is identical to \livelink{chap:DWCFAadvanceloc}{DW\-\_CFA\-\_advance\-\_loc} except for the encoding
+is identical to \livelink{chap:DWCFAadvanceloc}{DW\_CFA\_advance\_loc} except for the encoding
 and size of the delta operand.
 
-\item \textbf{DW\-\_CFA\-\_advance\-\_loc2} \\
-The \livetarg{chap:DWCFAadvanceloc2}{DW\-\_CFA\-\_advance\-\_loc2} instruction takes a single uhalf
+\needlines{6}
+\item \textbf{DW\_CFA\_advance\_loc2} \\
+The \livetarg{chap:DWCFAadvanceloc2}{DW\_CFA\_advance\_loc2} instruction takes a single
+\addtoindex{uhalf}
 operand that represents a constant delta. This instruction
-is identical to \livelink{chap:DWCFAadvanceloc}{DW\-\_CFA\-\_advance\-\_loc} except for the encoding
+is identical to \livelink{chap:DWCFAadvanceloc}{DW\_CFA\_advance\_loc} except for the encoding
 and size of the delta operand.
 
-\item \textbf{DW\-\_CFA\-\_advance\-\_loc4} \\
-The \livetarg{chap:DWCFAadvanceloc4}{DW\-\_CFA\-\_advance\-\_loc4} instruction takes a single uword
+\item \textbf{DW\_CFA\_advance\_loc4} \\
+The \livetarg{chap:DWCFAadvanceloc4}{DW\_CFA\_advance\_loc4} instruction takes a single
+\addtoindex{uword}
 operand that represents a constant delta. This instruction
-is identical to \livelink{chap:DWCFAadvanceloc}{DW\-\_CFA\-\_advance\-\_loc} except for the encoding
+is identical to \livelink{chap:DWCFAadvanceloc}{DW\_CFA\_advance\_loc} except for the encoding
 and size of the delta operand.
 
 \end{enumerate}
 
 \subsubsection{CFA Definition Instructions}
 \label{chap:cfadefinitioninstructions}
+\begin{enumerate}[1. ]
 
-\begin{enumerate}[1.]
-\item \textbf{DW\-\_CFA\-\_def\-\_cfa} \\
-The \livetarg{chap:DWCFAdefcfa}{DW\-\_CFA\-\_def\-\_cfa} instruction takes two unsigned LEB128
+\item \textbf{DW\_CFA\_def\_cfa} \\
+The \livetarg{chap:DWCFAdefcfa}{DW\_CFA\_def\_cfa}
+instruction takes two unsigned LEB128\addtoindexx{LEB128!unsigned}
 operands representing a register number and a (non\dash factored)
 offset. The required action is to define the current CFA rule
 to use the provided register and offset.
 
-\item \textbf{ DW\-\_CFA\-\_def\-\_cfa\-\_sf} \\
-The \livetarg{chap:DWCFAdefcfasf}{DW\-\_CFA\-\_def\-\_cfa\-\_sf} instruction takes two operands:
-an unsigned LEB128 value representing a register number and a
-signed LEB128 factored offset. This instruction is identical
-to \livelink{chap:DWCFAdefcfa}{DW\-\_CFA\-\_def\-\_cfa} except that the second operand is signed
-and factored. The resulting offset is factored\_offset *
-\addtoindex{data\_alignment\_factor}.
-
-
-\item \textbf{DW\-\_CFA\-\_def\-\_cfa\-\_register} \\
-The \livetarg{chap:DWCFAdefcfaregister}{DW\-\_CFA\-\_def\-\_cfa\-\_register} instruction takes a single
-unsigned LEB128 operand representing a register number. The
+\needlines{6}
+\item \textbf{ DW\_CFA\_def\_cfa\_sf} \\
+The \livetarg{chap:DWCFAdefcfasf}{DW\_CFA\_def\_cfa\_sf} instruction takes two operands:
+an unsigned LEB128 value\addtoindexx{LEB128!unsigned}
+representing a register number and a
+signed LEB128\addtoindexx{LEB128!signed} factored offset. This instruction is identical
+to \livelink{chap:DWCFAdefcfa}{DW\_CFA\_def\_cfa} except that the second operand is signed
+and factored. The resulting offset is \textit{factored\_offset} *
+\addttindex{data\_alignment\_factor}.
+
+
+\item \textbf{DW\_CFA\_def\_cfa\_register} \\
+The \livetarg{chap:DWCFAdefcfaregister}{DW\_CFA\_def\_cfa\_register} 
+instruction takes a single
+unsigned LEB128\addtoindexx{LEB128!unsigned} operand representing a register number. The
 required action is to define the current CFA rule to use
 the provided register (but to keep the old offset). This
 operation is valid only if the current CFA rule is defined
@@ -1599,103 +1752,115 @@ to use a register and offset.
 
 
 
-\item \textbf{DW\-\_CFA\-\_def\-\_cfa\-\_offset} \\
-The \livetarg{chap:DWCFAdefcfaoffset}{DW\-\_CFA\-\_def\-\_cfa\-\_offset} instruction takes a single
-unsigned LEB128 operand representing a (non-factored)
+\item \textbf{DW\_CFA\_def\_cfa\_offset} \\
+The \livetarg{chap:DWCFAdefcfaoffset}{DW\_CFA\_def\_cfa\_offset} instruction takes a single
+unsigned LEB128\addtoindexx{LEB128!unsigned} operand representing a (non-factored)
 offset. The required action is to define the current CFA rule
 to use the provided offset (but to keep the old register). This
 operation is valid only if the current CFA rule is defined
 to use a register and offset.
 
 
-\item \textbf{DW\-\_CFA\-\_def\-\_cfa\-\_offset\-\_sf} \\
-The \livetarg{chap:DWCFAdefcfaoffsetsf}{DW\-\_CFA\-\_def\-\_cfa\-\_offset\-\_sf} instruction takes a signed
-LEB128 operand representing a factored offset. This instruction
-is identical to \livelink{chap:DWCFAdefcfaoffset}{DW\-\_CFA\-\_def\-\_cfa\-\_offset} except that the
+\item \textbf{DW\_CFA\_def\_cfa\_offset\_sf} \\
+The \livetarg{chap:DWCFAdefcfaoffsetsf}{DW\_CFA\_def\_cfa\_offset\_sf} instruction takes a signed
+LEB128\addtoindexx{LEB128!signed} operand representing a factored offset. This instruction
+is identical to \livelink{chap:DWCFAdefcfaoffset}{DW\_CFA\_def\_cfa\_offset} except that the
 operand is signed and factored. The resulting offset is
-factored\_offset * \addtoindex{data\_alignment\_factor}.
+\textit{factored\_offset} * \addttindex{data\_alignment\_factor}.
 This operation
 is valid only if the current CFA rule is defined to use a
 register and offset.
 
-\item \textbf{DW\-\_CFA\-\_def\-\_cfa\-\_expression} \\
-The \livetarg{chap:DWCFAdefcfaexpression}{DW\-\_CFA\-\_def\-\_cfa\-\_expression} instruction takes a single
-operand encoded as a \livelink{chap:DWFORMexprloc}{DW\-\_FORM\-\_exprloc} value representing a
+\item \textbf{DW\_CFA\_def\_cfa\_expression} \\
+The \livetarg{chap:DWCFAdefcfaexpression}{DW\_CFA\_def\_cfa\_expression} 
+instruction takes a 
+\addtoindexx{exprloc class}
+single operand encoded as a 
+\livelink{chap:DWFORMexprloc}{DW\_FORM\_exprloc} value representing a
 DWARF expression. The required action is to establish that
 expression as the means by which the current CFA is computed.
-See 
-Section \refersec{chap:callframeinstructions} 
+
+\textit{See Section \refersec{chap:callframeinstructions} 
 regarding restrictions on the DWARF
-expression operators that can be used.
+expression operators that can be used.}
 
 \end{enumerate}
 
 \subsubsection{Register Rule Instructions}
 \label{chap:registerruleinstructions}
+\begin{enumerate}[1. ]
 
-\begin{enumerate}[1.]
-\item \textbf{DW\-\_CFA\-\_undefined} \\
-The \livetarg{chap:DWCFAundefined}{DW\-\_CFA\-\_undefined} instruction takes a single unsigned
-LEB128 operand that represents a register number. The required
+\item \textbf{DW\_CFA\_undefined} \\
+The \livetarg{chap:DWCFAundefined}{DW\_CFA\_undefined} instruction takes a single unsigned
+LEB128\addtoindexx{LEB128!unsigned} operand that represents a register number. The required
 action is to set the rule for the specified register to
-``undefined.''
+\doublequote{undefined.}
 
-\item \textbf{DW\-\_CFA\-\_same\-\_value} \\
-The \livetarg{chap:DWCFAsamevalue}{DW\-\_CFA\-\_same\-\_value} instruction takes a single unsigned
-LEB128 operand that represents a register number. The required
+\item \textbf{DW\_CFA\_same\_value} \\
+The \livetarg{chap:DWCFAsamevalue}{DW\_CFA\_same\_value} instruction takes a single unsigned
+LEB128 operand\addtoindexx{LEB128!unsigned} that represents a register number. The required
 action is to set the rule for the specified register to
-``same value.''
+\doublequote{same value.}
 
-\item \textbf{DW\-\_CFA\-\_offset} \\
-The \livetarg{chap:DWCFAoffset}{DW\-\_CFA\-\_offset} instruction takes two operands: a register
-number (encoded with the opcode) and an unsigned LEB128
+\item \textbf{DW\_CFA\_offset} \\
+The \livetarg{chap:DWCFAoffset}{DW\_CFA\_offset} instruction takes two operands: a register
+number (encoded with the opcode) and an unsigned LEB128\addtoindexx{LEB128!unsigned}
 constant representing a factored offset. The required action
 is to change the rule for the register indicated by the
 register number to be an offset(N) rule where the value of
 N is 
-\textit{factored offset * \addtoindex{data\_alignment\_factor}}.
-
-\item \textbf{DW\-\_CFA\-\_offset\-\_extended} \\
-The \livetarg{chap:DWCFAoffsetextended}{DW\-\_CFA\-\_offset\-\_extended} instruction takes two unsigned
-LEB128 operands representing a register number and a factored
-offset. This instruction is identical to \livelink{chap:DWCFAoffset}{DW\-\_CFA\-\_offset} except
-for the encoding and size of the register operand.
-
-\item \textbf{ DW\-\_CFA\-\_offset\-\_extended\-\_sf} \\
-The \livetarg{chap:DWCFAoffsetextendedsf}{DW\-\_CFA\-\_offset\-\_extended\-\_sf} instruction takes two operands:
-an unsigned LEB128 value representing a register number and a
+\textit{factored offset} * \addttindex{data\_alignment\_factor}.
+
+\item \textbf{DW\_CFA\_offset\_extended} \\
+The \livetarg{chap:DWCFAoffsetextended}{DW\_CFA\_offset\_extended} 
+instruction takes two unsigned LEB128\addtoindexx{LEB128!unsigned} 
+operands representing a register number and a factored
+offset. This instruction is identical to
+\livelink{chap:DWCFAoffset}{DW\_CFA\_offset} 
+except for the encoding and size of the register operand.
+
+\item \textbf{ DW\_CFA\_offset\_extended\_sf} \\
+The \livetarg{chap:DWCFAoffsetextendedsf}{DW\_CFA\_offset\_extended\_sf} 
+instruction takes two operands:
+an unsigned LEB128\addtoindexx{LEB128!unsigned} 
+value representing a register number and a
 signed LEB128 factored offset. This instruction is identical
-to \livelink{chap:DWCFAoffsetextended}{DW\-\_CFA\-\_offset\-\_extended} except that the second operand is
+to \livelink{chap:DWCFAoffsetextended}{DW\_CFA\_offset\_extended} 
+except that the second operand is
 signed and factored. The resulting offset is 
-\textit{factored\_offset * \addtoindex{data\_alignment\_factor}}.
+\textit{factored\_offset} * \addttindex{data\_alignment\_factor}.
 
-\item \textbf{DW\-\_CFA\-\_val\-\_offset} \\
-The \livetarg{chap:DWCFAvaloffset}{DW\-\_CFA\-\_val\-\_offset} instruction takes two unsigned
-LEB128 operands representing a register number and a
+\item \textbf{DW\_CFA\_val\_offset} \\
+The \livetarg{chap:DWCFAvaloffset}{DW\_CFA\_val\_offset} 
+instruction takes two unsigned
+LEB128 operands\addtoindexx{LEB128!unsigned} representing a register number and a
 factored offset. The required action is to change the rule
 for the register indicated by the register number to be a
 val\_offset(N) rule where the value of N is 
-\textit{factored\_offset * \addtoindex{data\_alignment\_factor}}.
-
-\item \textbf{DW\-\_CFA\-\_val\-\_offset\-\_sf} \\
-The \livetarg{chap:DWCFAvaloffsetsf}{DW\-\_CFA\-\_val\-\_offset\-\_sf} instruction takes two operands: an
-unsigned LEB128 value representing a register number and a
-signed LEB128 factored offset. This instruction is identical
-to \livelink{chap:DWCFAvaloffset}{DW\-\_CFA\-\_val\-\_offset} except that the second operand is signed
+\textit{factored\_offset} * \addttindex{data\_alignment\_factor}.
+
+\needlines{6}
+\item \textbf{DW\_CFA\_val\_offset\_sf} \\
+The \livetarg{chap:DWCFAvaloffsetsf}{DW\_CFA\_val\_offset\_sf} instruction takes two operands: an
+unsigned LEB128\addtoindexx{LEB128!unsigned} value representing a register number and a
+signed LEB128\addtoindexx{LEB128!signed} factored offset. This instruction is identical
+to \livelink{chap:DWCFAvaloffset}{DW\_CFA\_val\_offset} except that the second operand is signed
 and factored. The resulting offset is 
-\textit{factored\_offset * \addtoindex{data\_alignment\_factor}}.
+\textit{factored\_offset} * \addttindex{data\_alignment\_factor}.
 
-\item \textbf{DW\-\_CFA\-\_register} \\
-The \livetarg{chap:DWCFAregister}{DW\-\_CFA\-\_register} instruction takes two unsigned LEB128
+\item \textbf{DW\_CFA\_register} \\
+The \livetarg{chap:DWCFAregister}{DW\_CFA\_register} 
+instruction takes two unsigned LEB128\addtoindexx{LEB128!unsigned}
 operands representing register numbers. The required action
 is to set the rule for the first register to be register(R)
 where R is the second register.
 
-\item \textbf{DW\-\_CFA\-\_expression} \\
-The \livetarg{chap:DWCFAexpression}{DW\-\_CFA\-\_expression} 
+\item \textbf{DW\_CFA\_expression} \\
+The \livetarg{chap:DWCFAexpression}{DW\_CFA\_expression} 
 instruction takes two operands: an
-unsigned LEB128 value representing a register number, and
-a \livelink{chap:DWFORMblock}{DW\-\_FORM\-\_block} 
+unsigned LEB128\addtoindexx{LEB128!unsigned} 
+value representing a register number, and
+a \livelink{chap:DWFORMblock}{DW\_FORM\_block} 
 value representing a DWARF expression. 
 The
 required action is to change the rule for the register
@@ -1705,14 +1870,16 @@ expression computes the address. The value of the CFA is
 pushed on the DWARF evaluation stack prior to execution of
 the DWARF expression.
 
-See Section \refersec{chap:callframeinstructions} 
+\textit{See Section \refersec{chap:callframeinstructions} 
 regarding restrictions on the DWARF
-expression operators that can be used.
-
-\item \textbf{DW\-\_CFA\-\_val\-\_expression} \\
-The \livetarg{chap:DWCFAvalexpression}{DW\-\_CFA\-\_val\-\_expression} instruction takes two operands:
-an unsigned LEB128 value representing a register number, and
-a \livelink{chap:DWFORMblock}{DW\-\_FORM\-\_block} 
+expression operators that can be used.}
+
+\needlines{7}
+\item \textbf{DW\_CFA\_val\_expression} \\
+The \livetarg{chap:DWCFAvalexpression}{DW\_CFA\_val\_expression} instruction takes two operands:
+an unsigned LEB128\addtoindexx{LEB128!unsigned} 
+value representing a register number, and
+a \livelink{chap:DWFORMblock}{DW\_FORM\_block} 
 value representing a DWARF expression. The
 required action is to change the rule for the register
 indicated by the register number to be a val\_expression(E)
@@ -1721,21 +1888,24 @@ expression computes the value of the given register. The value
 of the CFA is pushed on the DWARF evaluation stack prior to
 execution of the DWARF expression.
 
-See Section \refersec{chap:callframeinstructions} 
+\textit{See Section \refersec{chap:callframeinstructions} 
 regarding restrictions on the DWARF
-expression operators that can be used.
+expression operators that can be used.}
 
-\item \textbf{ DW\-\_CFA\-\_restore} \\
-The \livetarg{chap:DWCFArestore}{DW\-\_CFA\-\_restore} instruction takes a single operand (encoded
+\needlines{6}
+\item \textbf{ DW\_CFA\_restore} \\
+The \livetarg{chap:DWCFArestore}{DW\_CFA\_restore} instruction takes a single operand (encoded
 with the opcode) that represents a register number. The
 required action is to change the rule for the indicated
-register to the rule assigned it by the initial\_instructions
+register to the rule assigned it by the \texttt{initial\_instructions}
 in the CIE.
 
-\item \textbf{DW\-\_CFA\-\_restore\-\_extended} \\
-The \livetarg{chap:DWCFArestoreextended}{DW\-\_CFA\-\_restore\-\_extended} instruction takes a single unsigned
-LEB128 operand that represents a register number. This
-instruction is identical to \livelink{chap:DWCFArestore}{DW\-\_CFA\-\_restore} except for the
+\needlines{5}
+\item \textbf{DW\_CFA\_restore\_extended} \\
+The \livetarg{chap:DWCFArestoreextended}{DW\_CFA\_restore\_extended}
+instruction takes a single unsigned LEB128\addtoindexx{LEB128!unsigned} 
+operand that represents a register number. This
+instruction is identical to \livelink{chap:DWCFArestore}{DW\_CFA\_restore} except for the
 encoding and size of the register operand.
 
 \end{enumerate}
@@ -1745,20 +1915,21 @@ encoding and size of the register operand.
 
 \textit{The next two instructions provide the ability to stack and
 retrieve complete register states. They may be useful, for
-example, for a compiler that moves epilogue code into the
+example, for a compiler that moves \addtoindex{epilogue} code 
+into the
 body of a function.}
 
 
-\begin{enumerate}[1.]
+\begin{enumerate}[1. ]
 
-\item \textbf{DW\-\_CFA\-\_remember\-\_state} \\
-The \livetarg{chap:DWCFArememberstate}{DW\-\_CFA\-\_remember\-\_state} instruction takes no operands. The
+\item \textbf{DW\_CFA\_remember\_state} \\
+The \livetarg{chap:DWCFArememberstate}{DW\_CFA\_remember\_state} instruction takes no operands. The
 required action is to push the set of rules for every register
 onto an implicit stack.
 
-
-\item \textbf{DW\-\_CFA\-\_restore\-\_state} \\
-The \livetarg{chap:DWCFArestorestate}{DW\-\_CFA\-\_restore\-\_state} instruction takes no operands. The
+\needlines{4}
+\item \textbf{DW\_CFA\_restore\_state} \\
+The \livetarg{chap:DWCFArestorestate}{DW\_CFA\_restore\_state} instruction takes no operands. The
 required action is to pop the set of rules off the implicit
 stack and place them in the current row.
 
@@ -1766,9 +1937,9 @@ stack and place them in the current row.
 
 \subsubsection{Padding Instruction}
 \label{chap:paddinginstruction}
-\begin{enumerate}[1.]
-\item \textbf{DW\-\_CFA\-\_nop} \\
-The \livetarg{chap:DWCFAnop}{DW\-\_CFA\-\_nop} instruction has no operands and no required
+\begin{enumerate}[1. ]
+\item \textbf{DW\_CFA\_nop} \\
+The \livetarg{chap:DWCFAnop}{DW\_CFA\_nop} instruction has no operands and no required
 actions. It is used as padding to make a CIE or FDE an
 appropriate size
 
@@ -1779,26 +1950,26 @@ appropriate size
 
 \textit{To determine the virtual unwind rule set for a given location
 (L1), one searches through the FDE headers looking at the
-initial\_location and address\_range values to see if L1 is
+\texttt{initial\_location} and \texttt{address\_range} values to see if L1 is
 contained in the FDE. If so, then:}
-
-\begin{enumerate}[1.]
+\begin{enumerate}[1. ]
 
 \item \textit{Initialize a register set by reading the
-initial\_instructions field of the associated CIE.}
+\texttt{initial\_instructions} field of the associated CIE.}
 
-\item \textit{Read and process the FDEs instruction
-sequence until a \livelink{chap:DWCFAadvanceloc}{DW\-\_CFA\-\_advance\-\_loc}, 
-\livelink{chap:DWCFAsetloc}{DW\-\_CFA\-\_set\-\_loc}, or the
+\item \textit{Read and process the FDE\textquoteright s instruction
+sequence until a \livelink{chap:DWCFAadvanceloc}{DW\_CFA\_advance\_loc}, 
+\livelink{chap:DWCFAsetloc}{DW\_CFA\_set\_loc}, or the
 end of the instruction stream is encountered.}
 
-\item \textit{ If a \livelink{chap:DWCFAadvanceloc}{DW\-\_CFA\-\_advance\-\_loc} or \livelink{chap:DWCFAsetloc}{DW\-\_CFA\-\_set\-\_loc}
+\item \textit{ If a \livelink{chap:DWCFAadvanceloc}{DW\_CFA\_advance\_loc} or 
+\livelink{chap:DWCFAsetloc}{DW\_CFA\_set\_loc}
 instruction is encountered, then compute a new location value
-(L2). If L1 >= L2 then process the instruction and go back
+(L2). If L1 $\geq$ L2 then process the instruction and go back
 to step 2.}
 
 \item \textit{ The end of the instruction stream can be thought
-of as a \livelink{chap:DWCFAsetloc}{DW\-\_CFA\-\_set\-\_loc} (initial\_location + address\_range)
+of as a \livelink{chap:DWCFAsetloc}{DW\_CFA\_set\_loc} (\texttt{initial\_location + address\_range})
 instruction. Note that the FDE is ill-formed if L2 is less
 than L1.}
 
@@ -1822,7 +1993,7 @@ Return Address.}
 
 If a Return Address register is defined in the virtual
 unwind table, and its rule is undefined (for example, by
-\livelink{chap:DWCFAundefined}{DW\-\_CFA\-\_undefined}), then there is no return address and no
+\livelink{chap:DWCFAundefined}{DW\_CFA\_undefined}), then there is no return address and no
 call address, and the virtual unwind of stack activations
 is complete.