This completes (many!) changes resulting from reviews over the
[dwarf-doc.git] / dwarf5 / latexdoc / generaldescription.tex
index f2cc8cd..2d74561 100644 (file)
@@ -599,7 +599,7 @@ value is truncated to the element size and the low\dash order bits
 are pushed on the stack.
 \begin{enumerate}[1. ]
 \itembfnl{\livetarg{chap:DWOPlit0}{DW\_OP\_lit0}, \livetarg{chap:DWOPlit1}{DW\_OP\_lit1}, \dots, \livetarg{chap:DWOPlit31}{DW\_OP\_lit31}}
-The \livetarg{chap:DWOPlit}{DW\_OP\_lit}n operations encode the unsigned literal values
+The \livetarg{chap:DWOPlit}{DW\_OP\_lit}\textit{n} operations encode the unsigned literal values
 from 0 through 31, inclusive.
 
 \itembfnl{\livetarg{chap:DWOPaddr}{DW\_OP\_addr}}
@@ -611,16 +611,16 @@ on the target machine.
 The single operand of a \livetarg{chap:DWOPconstnu}{DW\_OP\_constnu} operation provides a 1,
 2, 4, or 8\dash byte unsigned integer constant, respectively.
 
-\itembfnl{\livetarg{chap:DWOPconst1s}{DW\_OP\_const1s} , \livetarg{chap:DWOPconst2s}{DW\_OP\_const2s}, \livetarg{chap:DWOPconst4s}{DW\_OP\_const4s}, \livetarg{chap:DWOPconst8s}{DW\_OP\_const8s}}
+\itembfnl{\livetarg{chap:DWOPconst1s}{DW\_OP\_const1s}, \livetarg{chap:DWOPconst2s}{DW\_OP\_const2s}, \livetarg{chap:DWOPconst4s}{DW\_OP\_const4s}, \livetarg{chap:DWOPconst8s}{DW\_OP\_const8s}}
 The single operand of a \livetarg{chap:DWOPconstns}{DW\_OP\_constns} operation provides a 1,
 2, 4, or 8\dash byte signed integer constant, respectively.
 
 \itembfnl{\livetarg{chap:DWOPconstu}{DW\_OP\_constu}}
-The single operand of the \livelink{chap:DWOPconstu}{DW\_OP\_constu} operation provides
+The single operand of the \livetarg{chap:DWOPconstu}{DW\_OP\_constu} operation provides
 an unsigned LEB128 integer constant.
 
 \itembfnl{\livetarg{chap:DWOPconsts}{DW\_OP\_consts}}
-The single operand of the \livelink{chap:DWOPconsts}{DW\_OP\_consts} operation provides
+The single operand of the \livetarg{chap:DWOPconsts}{DW\_OP\_consts} operation provides
 a signed LEB128 integer constant.
 
 \end{enumerate}
@@ -634,7 +634,7 @@ the result of adding the contents of a register to a given
 signed offset.
 \begin{enumerate}[1. ]
 \itembfnl{\livetarg{chap:DWOPfbreg}{DW\_OP\_fbreg}}
-The \livelink{chap:DWOPfbreg}{DW\_OP\_fbreg} operation provides a signed LEB128 offset
+The \livetarg{chap:DWOPfbreg}{DW\_OP\_fbreg} operation provides a signed LEB128 offset
 from the address specified by the location description in the
 \livelink{chap:DWATframebase}{DW\_AT\_frame\_base} attribute of the current function. (This
 is typically a \doublequote{stack pointer} register plus or minus
@@ -649,7 +649,7 @@ a signed LEB128 offset from
 the specified register.
 
 \itembfnl{\livetarg{chap:DWOPbregx}{DW\_OP\_bregx} }
-The \livelink{chap:DWOPbregx}{DW\_OP\_bregx} operation has two operands: a register
+The \livetarg{chap:DWOPbregx}{DW\_OP\_bregx} operation has two operands: a register
 which is specified by an unsigned LEB128 number, followed by
 a signed LEB128 offset.
 
@@ -665,36 +665,36 @@ that index the stack assume that the top of the stack (most
 recently added entry) has index 0.
 \begin{enumerate}[1. ]
 \itembfnl{\livetarg{chap:DWOPdup}{DW\_OP\_dup}}
-The \livelink{chap:DWOPdup}{DW\_OP\_dup} operation duplicates the value at the top of the stack.
+The \livetarg{chap:DWOPdup}{DW\_OP\_dup} operation duplicates the value at the top of the stack.
 
 \itembfnl{\livetarg{chap:DWOPdrop}{DW\_OP\_drop}}
-The \livelink{chap:DWOPdrop}{DW\_OP\_drop} operation pops the value at the top of the stack.
+The \livetarg{chap:DWOPdrop}{DW\_OP\_drop} operation pops the value at the top of the stack.
 
 \itembfnl{\livetarg{chap:DWOPpick}{DW\_OP\_pick}}
-The single operand of the \livelink{chap:DWOPpick}{DW\_OP\_pick} operation provides a
+The single operand of the \livetarg{chap:DWOPpick}{DW\_OP\_pick} operation provides a
 1\dash byte index. A copy of the stack entry with the specified
 index (0 through 255, inclusive) is pushed onto the stack.
 
 \itembfnl{\livetarg{chap:DWOPover}{DW\_OP\_over}}
-The \livelink{chap:DWOPover}{DW\_OP\_over} operation duplicates the entry currently second
+The \livetarg{chap:DWOPover}{DW\_OP\_over} operation duplicates the entry currently second
 in the stack at the top of the stack. 
 This is equivalent to
 a \livelink{chap:DWOPpick}{DW\_OP\_pick} operation, with index 1.  
 
 \itembfnl{\livetarg{chap:DWOPswap}{DW\_OP\_swap}}
-The \livelink{chap:DWOPswap}{DW\_OP\_swap} operation swaps the top two stack entries. 
+The \livetarg{chap:DWOPswap}{DW\_OP\_swap} operation swaps the top two stack entries. 
 The entry at the top of the
 stack becomes the second stack entry, 
 and the second entry becomes the top of the stack.
 
 \itembfnl{\livetarg{chap:DWOProt}{DW\_OP\_rot}}
-The \livelink{chap:DWOProt}{DW\_OP\_rot} operation rotates the first three stack
+The \livetarg{chap:DWOProt}{DW\_OP\_rot} operation rotates the first three stack
 entries. The entry at the top of the stack becomes the third
 stack entry, the second entry becomes the top of the stack,
 and the third entry becomes the second entry.
 
 \itembfnl{\livetarg{chap:DWOPderef}{DW\_OP\_deref}}
-The \livelink{chap:DWOPderef}{DW\_OP\_deref} 
+The \livetarg{chap:DWOPderef}{DW\_OP\_deref} 
 operation  pops the top stack entry and 
 treats it as an address. The value
 retrieved from that address is pushed. 
@@ -703,10 +703,11 @@ The size of the data retrieved from the
 address is the \addtoindex{size of an address} on the target machine.
 
 \itembfnl{\livetarg{chap:DWOPderefsize}{DW\_OP\_deref\_size}}
-The \livelink{chap:DWOPderefsize}{DW\_OP\_deref\_size} operation behaves like the \livelink{chap:DWOPderef}{DW\_OP\_deref}
+The \livetarg{chap:DWOPderefsize}{DW\_OP\_deref\_size} operation behaves like the 
+\livelink{chap:DWOPderef}{DW\_OP\_deref}
 operation: it pops the top stack entry and treats it as an
 address. The value retrieved from that address is pushed. In
-the \livelink{chap:DWOPderefsize}{DW\_OP\_deref\_size} operation, however, the size in bytes
+the \addtoindex{DW\_OP\_deref\_size} operation, however, the size in bytes
 of the data retrieved from the dereferenced address is
 specified by the single operand. This operand is a 1\dash byte
 unsigned integral constant whose value may not be larger
@@ -715,7 +716,7 @@ retrieved is zero extended to the size of an address on the
 target machine before being pushed onto the expression stack.
 
 \itembfnl{\livetarg{chap:DWOPxderef}{DW\_OP\_xderef}}
-The \livelink{chap:DWOPxderef}{DW\_OP\_xderef} operation provides an extended dereference
+The \livetarg{chap:DWOPxderef}{DW\_OP\_xderef} operation provides an extended dereference
 mechanism. The entry at the top of the stack is treated as an
 address. The second stack entry is treated as an \doublequote{address
 space identifier} for those architectures that support
@@ -729,8 +730,8 @@ address is the
 \addtoindex{size of an address} on the target machine.
 
 \itembfnl{\livetarg{chap:DWOPxderefsize}{DW\_OP\_xderef\_size}}
-The \livelink{chap:DWOPxderefsize}{DW\_OP\_xderef\_size} operation behaves like the
-\livelink{chap:DWOPxderef}{DW\_OP\_xderef} operation.The entry at the top of the stack is
+The \livetarg{chap:DWOPxderefsize}{DW\_OP\_xderef\_size} operation behaves like the
+\livelink{chap:DWOPxderef}{DW\_OP\_xderef} operation. The entry at the top of the stack is
 treated as an address. The second stack entry is treated as
 an \doublequote{address space identifier} for those architectures
 that support 
@@ -738,7 +739,7 @@ that support
 address spaces. The top two stack
 elements are popped, and a data item is retrieved through an
 implementation\dash defined address calculation and pushed as the
-new stack top. In the \livelink{chap:DWOPxderefsize}{DW\_OP\_xderef\_size} operation, however,
+new stack top. In the \addtoindex{DW\_OP\_xderef\_size} operation, however,
 the size in bytes of the data retrieved from the 
 \addtoindexi{dereferenced}{address!dereference operator}
 address is specified by the single operand. This operand is a
@@ -748,7 +749,7 @@ retrieved is zero extended to the \addtoindex{size of an address} on the
 target machine before being pushed onto the expression stack.
 
 \itembfnl{\livetarg{chap:DWOPpushobjectaddress}{DW\_OP\_push\_object\_address}}
-The \livelink{chap:DWOPpushobjectaddress}{DW\_OP\_push\_object\_address}
+The \livetarg{chap:DWOPpushobjectaddress}{DW\_OP\_push\_object\_address}
 operation pushes the address
 of the object currently being evaluated as part of evaluation
 of a user presented expression. This object may correspond
@@ -762,19 +763,20 @@ evaluation.
 (especially for arrays involving descriptors) that is analogous
 to the implicit push of the base 
 \addtoindexi{address}{address!implicit push of base}
-of a structure prior
-to evaluation of a \livelink{chap:DWATdatamemberlocation}{DW\_AT\_data\_member\_location} to access a
-data member of a structure. For an example, see 
+of a structure prior to evaluation of a 
+\livelink{chap:DWATdatamemberlocation}{DW\_AT\_data\_member\_location} 
+to access a data member of a structure. For an example, see 
 Appendix \refersec{app:aggregateexamples}.}
 
 \needlines{4}
 \itembfnl{\livetarg{chap:DWOPformtlsaddress}{DW\_OP\_form\_tls\_address}}
-The \livelink{chap:DWOPformtlsaddress}{DW\_OP\_form\_tls\_address} operation pops a value from the
+The \livetarg{chap:DWOPformtlsaddress}{DW\_OP\_form\_tls\_address} 
+operation pops a value from the
 stack, translates it into an address in the current thread's
 \addtoindexx{thread-local storage}
 thread\dash local storage \nolink{block}, and pushes the address. If the
 DWARF expression containing 
-the \livelink{chap:DWOPformtlsaddress}{DW\_OP\_form\_tls\_address}
+the \addtoindex{DW\_OP\_form\_tls\_address}
 operation belongs to the main executable's DWARF info, the
 operation uses the main executable's thread\dash local storage
 \nolink{block}; if the expression belongs to a shared library's
@@ -794,15 +796,16 @@ declared in each shared library. Computing the address of
 the appropriate \nolink{block} can be complex (in some cases, the
 compiler emits a function call to do it), and difficult
 to describe using ordinary DWARF location descriptions.
-\livelink{chap:DWOPformtlsaddress}{DW\_OP\_form\_tls\_address} leaves the computation to the
+\addtoindex{DW\_OP\_form\_tls\_address} leaves the computation to the
 consumer.}
 
 \itembfnl{\livetarg{chap:DWOPcallframecfa}{DW\_OP\_call\_frame\_cfa}}
-The \livelink{chap:DWOPcallframecfa}{DW\_OP\_call\_frame\_cfa} operation pushes the value of the
+The \livetarg{chap:DWOPcallframecfa}{DW\_OP\_call\_frame\_cfa} 
+operation pushes the value of the
 CFA, obtained from the Call Frame Information 
 (see Section \refersec{chap:callframeinformation}).
 
-\textit{Although the value of \livelink{chap:DWATframebase}{DW\_AT\_frame\_base}
+\textit{Although the value of \addtoindex{DW\_AT\_frame\_base}
 can be computed using other DWARF expression operators,
 in some cases this would require an extensive location list
 because the values of the registers used in computing the
@@ -827,49 +830,49 @@ bits).
 Such operations do not cause an exception on overflow.
 \begin{enumerate}[1. ]
 \itembfnl{\livetarg{chap:DWOPabs}{DW\_OP\_abs}}
-The \livelink{chap:DWOPabs}{DW\_OP\_abs} operation pops the top stack entry, interprets
+The \livetarg{chap:DWOPabs}{DW\_OP\_abs} operation pops the top stack entry, interprets
 it as a signed value and pushes its absolute value. If the
 absolute value cannot be represented, the result is undefined.
 
 \itembfnl{\livetarg{chap:DWOPand}{DW\_OP\_and}}
-The \livelink{chap:DWOPand}{DW\_OP\_and} operation pops the top two stack values, performs
+The \livetarg{chap:DWOPand}{DW\_OP\_and} operation pops the top two stack values, performs
 a bitwise and operation on the two, and pushes the result.
 
 \itembfnl{\livetarg{chap:DWOPdiv}{DW\_OP\_div}}
-The \livelink{chap:DWOPdiv}{DW\_OP\_div} operation pops the top two stack values, divides the former second entry by
+The \livetarg{chap:DWOPdiv}{DW\_OP\_div} operation pops the top two stack values, divides the former second entry by
 the former top of the stack using signed division, and pushes the result.
 
 \itembfnl{\livetarg{chap:DWOPminus}{DW\_OP\_minus}}
-The \livelink{chap:DWOPminus}{DW\_OP\_minus} operation pops the top two stack values, subtracts the former top of the
+The \livetarg{chap:DWOPminus}{DW\_OP\_minus} operation pops the top two stack values, subtracts the former top of the
 stack from the former second entry, and pushes the result.
 
 \itembfnl{\livetarg{chap:DWOPmod}{DW\_OP\_mod}}
-The \livelink{chap:DWOPmod}{DW\_OP\_mod} operation pops the top two stack values and pushes the result of the
+The \livetarg{chap:DWOPmod}{DW\_OP\_mod} operation pops the top two stack values and pushes the result of the
 calculation: former second stack entry modulo the former top of the stack.
 
 \itembfnl{\livetarg{chap:DWOPmul}{DW\_OP\_mul}}
-The \livelink{chap:DWOPmul}{DW\_OP\_mul} operation pops the top two stack entries, multiplies them together, and
+The \livetarg{chap:DWOPmul}{DW\_OP\_mul} operation pops the top two stack entries, multiplies them together, and
 pushes the result.
 
 \itembfnl{\livetarg{chap:DWOPneg}{DW\_OP\_neg}}
-The \livelink{chap:DWOPneg}{DW\_OP\_neg} operation pops the top stack entry, interprets
+The \livetarg{chap:DWOPneg}{DW\_OP\_neg} operation pops the top stack entry, interprets
 it as a signed value and pushes its negation. If the negation
 cannot be represented, the result is undefined.
 
 \itembfnl{\livetarg{chap:DWOPnot}{DW\_OP\_not}}
-The \livelink{chap:DWOPnot}{DW\_OP\_not} operation pops the top stack entry, and pushes
+The \livetarg{chap:DWOPnot}{DW\_OP\_not} operation pops the top stack entry, and pushes
 its bitwise complement.
 
 \itembfnl{\livetarg{chap:DWOPor}{DW\_OP\_or}}
-The \livelink{chap:DWOPor}{DW\_OP\_or} operation pops the top two stack entries, performs
+The \livetarg{chap:DWOPor}{DW\_OP\_or} operation pops the top two stack entries, performs
 a bitwise or operation on the two, and pushes the result.
 
 \itembfnl{\livetarg{chap:DWOPplus}{DW\_OP\_plus}}
-The \livelink{chap:DWOPplus}{DW\_OP\_plus} operation pops the top two stack entries,
+The \livetarg{chap:DWOPplus}{DW\_OP\_plus} operation pops the top two stack entries,
 adds them together, and pushes the result.
 
 \itembfnl{\livetarg{chap:DWOPplusuconst}{DW\_OP\_plus\_uconst}}
-The \livelink{chap:DWOPplusuconst}{DW\_OP\_plus\_uconst} operation pops the top stack entry,
+The \livetarg{chap:DWOPplusuconst}{DW\_OP\_plus\_uconst} operation pops the top stack entry,
 adds it to the unsigned LEB128 constant operand and pushes
 the result.
 
@@ -880,27 +883,27 @@ done with
 
 \needlines{3}
 \itembfnl{\livetarg{chap:DWOPshl}{DW\_OP\_shl}}
-The \livelink{chap:DWOPshl}{DW\_OP\_shl} operation pops the top two stack entries,
+The \livetarg{chap:DWOPshl}{DW\_OP\_shl} operation pops the top two stack entries,
 shifts the former second entry left (filling with zero bits)
 by the number of bits specified by the former top of the stack,
 and pushes the result.
 
 \itembfnl{\livetarg{chap:DWOPshr}{DW\_OP\_shr}}
-The \livelink{chap:DWOPshr}{DW\_OP\_shr} operation pops the top two stack entries,
+The \livetarg{chap:DWOPshr}{DW\_OP\_shr} operation pops the top two stack entries,
 shifts the former second entry right logically (filling with
 zero bits) by the number of bits specified by the former top
 of the stack, and pushes the result.
 
 \needlines{6}
 \itembfnl{\livetarg{chap:DWOPshra}{DW\_OP\_shra}}
-The \livelink{chap:DWOPshra}{DW\_OP\_shra} operation pops the top two stack entries,
+The \livetarg{chap:DWOPshra}{DW\_OP\_shra} operation pops the top two stack entries,
 shifts the former second entry right arithmetically (divide
 the magnitude by 2, keep the same sign for the result) by
 the number of bits specified by the former top of the stack,
 and pushes the result.
 
 \itembfnl{\livetarg{chap:DWOPxor}{DW\_OP\_xor}}
-The \livelink{chap:DWOPxor}{DW\_OP\_xor} operation pops the top two stack entries,
+The \livetarg{chap:DWOPxor}{DW\_OP\_xor} operation pops the top two stack entries,
 performs a bitwise exclusive\dash or operation on the two, and
 pushes the result.
 
@@ -927,20 +930,20 @@ constant value 0 if the result of the operation is false.
 \end{itemize}
 
 Comparisons are performed as signed operations. The six
-operators are \livelink{chap:DWOPle}{DW\_OP\_le} (less than or equal to), \livelink{chap:DWOPge}{DW\_OP\_ge}
-(greater than or equal to), \livelink{chap:DWOPeq}{DW\_OP\_eq} (equal to), \livelink{chap:DWOPlt}{DW\_OP\_lt} (less
-than), \livelink{chap:DWOPgt}{DW\_OP\_gt} (greater than) and \livelink{chap:DWOPne}{DW\_OP\_ne} (not equal to).
+operators are \addtoindex{DW\_OP\_le} (less than or equal to), \addtoindex{DW\_OP\_ge}
+(greater than or equal to), \addtoindex{DW\_OP\_eq} (equal to), \addtoindex{DW\_OP\_lt} (less
+than), \addtoindex{DW\_OP\_gt} (greater than) and \addtoindex{DW\_OP\_ne} (not equal to).
 
 \needlines{6}
 \itembfnl{\livetarg{chap:DWOPskip}{DW\_OP\_skip}}
-\livelink{chap:DWOPskip}{DW\_OP\_skip} is an unconditional branch. Its single operand
+\livetarg{chap:DWOPskip}{DW\_OP\_skip} is an unconditional branch. Its single operand
 is a 2\dash byte signed integer constant. The 2\dash byte constant is
 the number of bytes of the DWARF expression to skip forward
 or backward from the current operation, beginning after the
 2\dash byte constant.
 
 \itembfnl{\livetarg{chap:DWOPbra}{DW\_OP\_bra}}
-\livelink{chap:DWOPbra}{DW\_OP\_bra} is a conditional branch. Its single operand is a
+\livetarg{chap:DWOPbra}{DW\_OP\_bra} is a conditional branch. Its single operand is a
 2\dash byte signed integer constant.  This operation pops the
 top of stack. If the value popped is not the constant 0,
 the 2\dash byte constant operand is the number of bytes of the
@@ -951,33 +954,31 @@ operation, beginning after the 2\dash byte constant.
 % to an overfull hbox and a visible artifact. 
 % So we use \- to suggest hyphenation in this rare situation.
 \itembfnl{\livetarg{chap:DWOPcall2}{DW\_OP\_call2}, \livetarg{chap:DWOPcall4}{DW\_OP\_call4}, \livetarg{chap:DWOPcallref}{DW\_OP\_call\_ref}}
-\livelink{chap:DWOPcall2}{DW\_OP\_call2}, 
-\livelink{chap:DWOPcall4}{DW\_OP\_call4}, 
-and \livelink{chap:DWOPcallref}{DW\_OP\_call\_ref} perform
+\addtoindex{DW\_OP\_call2}, 
+\addtoindex{DW\_OP\_call4}, 
+and \addtoindex{DW\_OP\_call\_ref} perform
 subroutine calls during evaluation of a DWARF expression or
 location description. 
-For \livelink{chap:DWOPcall2}{DW\_OP\_call2} and 
-\livelink{chap:DWOPcall4}{DW\_OP\_call4}, 
-the
-operand is the 2\dash~ or 4\dash byte 
-unsigned offset, respectively,
+For \addtoindex{DW\_OP\_call2} and \addtoindex{DW\_OP\_call4}, 
+the operand is the 2\dash~ or 4\dash byte unsigned offset, respectively,
 of a debugging information entry in the current compilation
-unit. The \livelink{chap:DWOPcallref}{DW\_OP\_call\_ref} operator has a single operand. In the
-32\dash bit DWARF format, the operand is a 4\dash byte unsigned value;
-in the 64\dash bit DWARF format, it is an 8\dash byte unsigned value
+unit. The \addtoindex{DW\_OP\_call\_ref} operator has a single operand. In the
+\thirtytwobitdwarfformat,
+the operand is a 4\dash byte unsigned value;
+in the \sixtyfourbitdwarfformat, it is an 8\dash byte unsigned value
 (see Section \refersec{datarep:32bitand64bitdwarfformats}). 
 The operand is used as the offset of a
 debugging information entry in a 
-\addtoindex{.debug\_info}
+\dotdebuginfo{}
 or
-\addtoindex{.debug\_types}
+\dotdebugtypes{}
 section which may be contained in a shared object or executable
 other than that containing the operator. For references from
 one shared object or executable to another, the relocation
 must be performed by the consumer.  
 
 \textit{Operand interpretation of
-\livelink{chap:DWOPcall2}{DW\_OP\_call2}, \livelink{chap:DWOPcall4}{DW\_OP\_call4} and \livelink{chap:DWOPcallref}{DW\_OP\_call\_ref} is exactly like
+\addtoindex{DW\_OP\_call2}, \addtoindex{DW\_OP\_call4} and \addtoindex{DW\_OP\_call\_ref} is exactly like
 that for \livelink{chap:DWFORMref2}{DW\_FORM\_ref2}, \livelink{chap:DWFORMref4}{DW\_FORM\_ref4} and \livelink{chap:DWFORMrefaddr}{DW\_FORM\_ref\_addr},
 respectively  
 (see Section  \refersec{datarep:attributeencodings}).  
@@ -1009,7 +1010,7 @@ There
 is one special operation currently defined:
 \begin{enumerate}[1. ]
 \itembfnl{\livetarg{chap:DWOPnop}{DW\_OP\_nop}}
-The \livelink{chap:DWOPnop}{DW\_OP\_nop} operation is a place holder. It has no effect
+The \livetarg{chap:DWOPnop}{DW\_OP\_nop} operation is a place holder. It has no effect
 on the location stack or any of its values.
 \end{enumerate}
 
@@ -1207,7 +1208,7 @@ registers, numbered from 0 through 31, inclusive. The object
 addressed is in register \textit{n}.
 
 \itembfnl{\livetarg{chap:DWOPregx}{DW\_OP\_regx}}
-The \livelink{chap:DWOPregx}{DW\_OP\_regx} operation has a single unsigned LEB128 literal
+The \livetarg{chap:DWOPregx}{DW\_OP\_regx} operation has a single unsigned LEB128 literal
 operand that encodes the name of a register.  
 
 \end{enumerate}
@@ -1234,7 +1235,8 @@ that has no location in the program but is a known constant
 or is computed from other locations and values in the program.
 \begin{enumerate}[1. ]
 \itembfnl{\livetarg{chap:DWOPimplicitvalue}{DW\_OP\_implicit\_value}}
-The \livelink{chap:DWOPimplicitvalue}{DW\_OP\_implicit\_value} operation specifies an immediate value
+The \livetarg{chap:DWOPimplicitvalue}{DW\_OP\_implicit\_value} 
+operation specifies an immediate value
 using two operands: an unsigned LEB128 length, followed by
 %FIXME: should this block be a reference? To what?
 a \nolink{block} representing the value in the memory representation
@@ -1242,12 +1244,13 @@ of the target machine. The length operand gives the length
 in bytes of the \nolink{block}.
 
 \itembfnl{\livetarg{chap:DWOPstackvalue}{DW\_OP\_stack\_value}}
-The \livelink{chap:DWOPstackvalue}{DW\_OP\_stack\_value} operation specifies that the object
+The \livetarg{chap:DWOPstackvalue}{DW\_OP\_stack\_value} 
+operation specifies that the object
 does not exist in memory but its value is nonetheless known
 and is at the top of the DWARF expression stack. In this form
 of location description, the DWARF expression represents the
 actual value of the object, rather than its location. The
-\livelink{chap:DWOPstackvalue}{DW\_OP\_stack\_value} operation terminates the expression.
+\addtoindex{DW\_OP\_stack\_value} operation terminates the expression.
 \end{enumerate}
 
 
@@ -1275,7 +1278,7 @@ location description which describes the location where part
 of the resultant value is contained.
 \begin{enumerate}[1. ]
 \itembfnl{\livetarg{chap:DWOPpiece}{DW\_OP\_piece}}
-The \livelink{chap:DWOPpiece}{DW\_OP\_piece} operation takes a 
+The \livetarg{chap:DWOPpiece}{DW\_OP\_piece} operation takes a 
 single operand, which is an
 unsigned LEB128 number.  The number describes the size in bytes
 of the piece of the object referenced by the preceding simple
@@ -1285,12 +1288,13 @@ the piece within that register is defined by the ABI.
 
 \textit{Many compilers store a single variable in sets of registers,
 or store a variable partially in memory and partially in
-registers. \livelink{chap:DWOPpiece}{DW\_OP\_piece} provides a way of describing how large
+registers. \addtoindex{DW\_OP\_piece} provides a way of describing how large
 a part of a variable a particular DWARF location description
 refers to. }
 
 \itembfnl{\livetarg{chap:DWOPbitpiece}{DW\_OP\_bit\_piece}}
-The \livelink{chap:DWOPbitpiece}{DW\_OP\_bit\_piece} operation takes two operands. The first
+The \livetarg{chap:DWOPbitpiece}{DW\_OP\_bit\_piece} 
+operation takes two operands. The first
 is an unsigned LEB128 number that gives the size in bits
 of the piece. The second is an unsigned LEB128 number that
 gives the offset in bits from the location defined by the
@@ -1299,22 +1303,22 @@ preceding DWARF location description.
 Interpretation of the
 offset depends on the kind of location description. If the
 location description is empty, the offset doesn\textquoteright t matter and
-the \livelink{chap:DWOPbitpiece}{DW\_OP\_bit\_piece} operation describes a piece consisting
+the \addtoindex{DW\_OP\_bit\_piece} operation describes a piece consisting
 of the given number of bits whose values are undefined. If
 the location is a register, the offset is from the least
 significant bit end of the register. If the location is a
-memory address, the \livelink{chap:DWOPbitpiece}{DW\_OP\_bit\_piece} operation describes a
+memory address, the \addtoindex{DW\_OP\_bit\_piece} operation describes a
 sequence of bits relative to the location whose address is
 on the top of the DWARF stack using the bit numbering and
 direction conventions that are appropriate to the current
 language on the target system. If the location is any implicit
-value or stack value, the \livelink{chap:DWOPbitpiece}{DW\_OP\_bit\_piece} operation describes
+value or stack value, the \addtoindex{DW\_OP\_bit\_piece} operation describes
 a sequence of bits using the least significant bits of that
 value.  
 \end{enumerate}
 
-\textit{\livelink{chap:DWOPbitpiece}{DW\_OP\_bit\_piece} is 
-used instead of \livelink{chap:DWOPpiece}{DW\_OP\_piece} when
+\textit{\addtoindex{DW\_OP\_bit\_piece} is 
+used instead of \addtoindex{DW\_OP\_piece} when
 the piece to be assembled into a value or assigned to is not
 byte-sized or is not at the start of a register or addressable
 unit of memory.}
@@ -1371,6 +1375,7 @@ Add the contents of r1 and r2 to compute a value. This value is the
 \doublequote{contents} of an otherwise anonymous location.
 
 \descriptionitemnl{\livelink{chap:DWOPlit1}{DW\_OP\_lit1} \livelink{chap:DWOPstackvalue}{DW\_OP\_stack\_value} \livelink{chap:DWOPpiece}{DW\_OP\_piece} 4 }
+\vspace{-\parsep}
 \descriptionitemnl{\livelink{chap:DWOPbreg}{DW\_OP\_breg3} 0 \livelink{chap:DWOPbreg}{DW\_OP\_breg4} 0 \livelink{chap:DWOPplus}{DW\_OP\_plus} \livelink{chap:DWOPstackvalue}{DW\_OP\_stack\_value} \livelink{chap:DWOPpiece}{DW\_OP\_piece} 4}
 The object value is found in an anonymous (virtual) location whose
 value consists of two parts, given in memory address order: the 4 byte
@@ -1389,9 +1394,9 @@ can change location during its lifetime.
 Location lists
 \addtoindexx{location list}
 are contained in a separate object file section called
-\addtoindex{.debug\_loc}. A location list is indicated by a location
+\dotdebugloc{}. A location list is indicated by a location
 attribute whose value is an offset from the beginning of
-the \addtoindex{.debug\_loc} section to the first byte of the list for the
+the \dotdebugloc{} section to the first byte of the list for the
 object in question.
 
 Each entry in a location list is either a location 
@@ -1997,12 +2002,12 @@ may have a value of class
 
 Range lists are contained
 in a separate object file section called 
-\addtoindex{.debug\_ranges}. A
+\dotdebugranges{}. A
 \addtoindex{range list} is indicated by a 
 \livelink{chap:DWATranges}{DW\_AT\_ranges} attribute whose
 \addtoindexx{ranges attribute}
 value is represented as an offset from the beginning of the
-\addtoindex{.debug\_ranges} section to the beginning of the 
+\dotdebugranges{} section to the beginning of the 
 \addtoindex{range list}.
 
 Each entry in a \addtoindex{range list} is either a