More changes from Committee review. This checkin corresponds to
[dwarf-doc.git] / dwarf5 / latexdoc / datarepresentation.tex
index d28f9a5..ca9892b 100644 (file)
@@ -277,9 +277,11 @@ units, in the \dotdebugabbrevdwo{} section.
 \item Location lists, in the \dotdebuglocdwo{} section.
 
 \item
-A skeleton line number table (for the type units), in the
-\dotdebuglinedwo{} section (see 
-Section \refersec{chap:skeletoncompilationunitentries}).
+A \addtoindex{specialized line number table} (for the type units), 
+in the \dotdebuglinedwo{} section. This table
+contains only the directory and filename lists needed to
+interpret \DWATdeclfile{} attributes in the debugging
+information entries.
 
 \item Macro information, in the \dotdebugmacrodwo{} section.
 
@@ -410,29 +412,48 @@ a table of sizes. The index sections are aligned at 8-byte
 boundaries in the file.
 
 \needlines{6}
-The index section header contains four unsigned 32-bit values:
-%(using the byte order of the application binary):
-\begin{itemize}
-\item The \addtoindexi{version number}{version number!package index tables}
- of the format of this index (currently \versiondotdebugcuindex)
-\item L, the number of columns in the table of section offsets
-\item N, the number of compilation units or type units in the index
-\item M, the number of slots in the hash table
-\end{itemize}
+The index section header contains the following fields:
+\begin{enumerate}[1. ]
+\item \texttt{version} (\HFTuhalf) \\
+A version number
+\addtoindexx{version number!CU index information} 
+\addtoindexx{version number!TU index information}
+(see Appendix \refersec{app:dwarfsectionversionnumbersinformative}). 
+This number is specific to the CU and TU index information
+and is independent of the DWARF version number.
+
+The version number is \versiondotdebugcuindex.
+
+\item \textit{padding} (\HFTuhalf) \\
+Reserved to DWARF.
+
+\item \texttt{column\_count} (\HFTuword) \\
+The number of columns in the table of section counts that follows.
+For brevity, the contents of this field is referred to as $C$ below.
+
+\item \texttt{unit\_count} (\HFTuword) \\
+The number of compilation units or type units in the index.
+For brevity, the contents of this field is referred to as $U$ below.
 
-\textit{We assume that N and M will not exceed $2^{32}$.}
+\item \texttt{slot\_count} (\HFTuword) \\
+The number of slots in the hash table.
+For brevity, the contents of this field is referred to as $S$ below.
 
-The size of the hash table, M, must be $2^k$ such that:
-\hspace{0.3cm}$2^k\ \ >\ \ 3*N/2$
+\end{enumerate}
+
+\textit{We assume that $U$ and $S$ do not exceed $2^{32}$.}
+
+The size of the hash table, $S$, must be $2^k$ such that:
+\hspace{0.3cm}$2^k\ \ >\ \ 3*U/2$
 
 The hash table begins at offset 16 in the section, and consists
-of an array of M 64-bit slots. Each slot contains a 64-bit
+of an array of $M$ 64-bit slots. Each slot contains a 64-bit
 signature.
 % (using the byte order of the application binary).
 
 The parallel table of indices begins immediately after the hash table 
-(at offset \mbox{16 + 8 * M} from the beginning of the section), and
-consists of an array of M 32-bit slots,
+(at offset \mbox{$16 + 8 * S$} from the beginning of the section), and
+consists of an array of $M$ 32-bit slots,
 % (using the byte order of the application binary), 
 corresponding 1-1 with slots in the hash
 table. Each entry in the parallel table contains a row index into
@@ -442,30 +463,31 @@ Unused slots in the hash table have 0 in both the hash table
 entry and the parallel table entry. While 0 is a valid hash
 value, the row index in a used slot will always be non-zero.
 
-Given a 64-bit compilation unit signature or a type signature S,
+Given a 64-bit compilation unit signature or a type signature $X$,
 an entry in the hash table is located as follows:
 \begin{enumerate}[1. ]
-\item Calculate a primary hash $H = S\ \&\ MASK(k)$, where $MASK(k)$ is a
-    mask with the low-order k bits all set to 1.
+\item Calculate a primary hash $H = X\ \&\ MASK(k)$, where $MASK(k)$ is a
+    mask with the low-order $k$ bits all set to 1.
 
-\item Calculate a secondary hash $H' = (((S>>32)\ \&\ MASK(k))\ |\ 1)$.
+\item Calculate a secondary hash $H' = (((X>>32)\ \&\ MASK(k))\ |\ 1)$.
 
-\item If the hash table entry at index H matches the signature, use
-    that entry. If the hash table entry at index H is unused (all
+\item If the hash table entry at index $H$ matches the signature, use
+    that entry. If the hash table entry at index $H$ is unused (all
     zeroes), terminate the search: the signature is not present
     in the table.
 
 \item Let $H = (H + H')\ modulo\ M$. Repeat at Step 3.
 \end{enumerate}
 
-Because $M > N$, and H' and M are relatively prime, the search is
+Because $M > U$, and $H'$ and $M$ are relatively prime, the search is
 guaranteed to stop at an unused slot or find the match.
 
 \needlines{4}
 The table of offsets begins immediately following the parallel
-table (at offset \mbox{16 + 12 * M} from the beginning of the section).
-The table is a two-dimensional array of 32-bit words (using the
-byte order of the application binary), with L columns and N+1
+table (at offset \mbox{$16 + 12 * S$} from the beginning of the section).
+The table is a two-dimensional array of 32-bit words, 
+%(using the byte order of the application binary), 
+with $C$ columns and $U + 1$
 rows, in row-major order. Each row in the array is indexed
 starting from 0. The first row provides a key to the columns:
 each column in this row provides a section identifier for a debug
@@ -473,6 +495,7 @@ section, and the offsets in the same column of subsequent rows
 refer to that section. The section identifiers are shown in
 Table \referfol{tab:dwarfpackagefilesectionidentifierencodings}.
 
+\needlines{12}
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \begin{longtable}{l|c|l}
@@ -515,7 +538,7 @@ The table of sizes begins immediately following the table of
 offsets, and provides the sizes of the contributions made by each
 CU or TU to the corresponding section in the package file. Like
 the table of offsets, it is a two-dimensional array of 32-bit
-words, with L columns and N rows, in row-major order. Each row in
+words, with $C$ columns and $U$ rows, in row-major order. Each row in
 the array is indexed starting from 1 (row 0 of the table of
 offsets also serves as the key for the table of sizes).
 
@@ -528,6 +551,7 @@ several executables or shared objects into a separate
 post-linking utility; the moved entries and strings can be then referenced
 from the debugging information of each of those executables or shared objects.
 
+\needlines{4}
 A DWARF supplementary object file is itself an object file, using the same object
 file format, byte order, and size as the corresponding application executables
 or shared libraries. It consists only of a file header, section table, and
@@ -537,13 +561,13 @@ file must contain a \dotdebugsup{} section that establishes the relationship.
 
 The \dotdebugsup{} section contains:
 \begin{enumerate}[1. ]
-\item \texttt{version} (uhalf) \\
+\item \texttt{version} (\HFTuhalf) \\
 \addttindexx{version}
 A 2-byte unsigned integer representing the version of the DWARF
 information for the compilation unit (see Appendix G). The
 value in this field is \versiondotdebugsup.
 
-\item \texttt{is\_supplementary} (ubyte) \\
+\item \texttt{is\_supplementary} (\HFTubyte) \\
 \addttindexx{is\_supplementary}
 A 1-byte unsigned integer, which contains the value 1 if it is
 in the \addtoindex{supplementary object file} that other executables or 
@@ -566,7 +590,7 @@ Length of the following \addttindex{sup\_checksum} field;
 his value can be 0 if no checksum is provided.
 
 
-\item \texttt{sup\_checksum} (array of ubyte) \\
+\item \texttt{sup\_checksum} (array of \HFTubyte) \\
 \addttindexx{sup\_checksum}
 Some checksum or cryptographic hash function of the \dotdebuginfo{}, 
 \dotdebugstr{} and \dotdebugmacro{} sections of the 
@@ -608,41 +632,41 @@ the executable or shared object."
 \hypertarget{datarep:xxbitdwffmt}{}
 \addtoindexx{32-bit DWARF format}
 \addtoindexx{64-bit DWARF format}
-There are two closely related file formats. In the 32\dash bit DWARF
+There are two closely related file formats. In the 32-bit DWARF
 format, all values that represent lengths of DWARF sections
 and offsets relative to the beginning of DWARF sections are
-represented using 32\dash bits. In the 64\dash bit DWARF format, all
+represented using 32-bits. In the 64-bit DWARF format, all
 values that represent lengths of DWARF sections and offsets
 relative to the beginning of DWARF sections are represented
-using 64\dash bits. A special convention applies to the initial
+using 64-bits. A special convention applies to the initial
 length field of certain DWARF sections, as well as the CIE and
-FDE structures, so that the 32\dash bit and 64\dash bit DWARF formats
+FDE structures, so that the 32-bit and 64-bit DWARF formats
 can coexist and be distinguished within a single linked object.
 
-The differences between the 32\dash\   and 64\dash bit 
-DWARF formats are
+The differences between the 32- and 64-bit DWARF formats are
 detailed in the following:
 \begin{enumerate}[1. ]
 
-\item  In the 32\dash bit DWARF format, an 
+\item  In the 32-bit DWARF format, an 
 \addtoindex{initial length} field (see 
 \addtoindexx{initial length!encoding}
 Section \ref{datarep:initiallengthvalues} on page \pageref{datarep:initiallengthvalues})
-is an unsigned 32\dash bit integer (which
-must be less than \xfffffffzero); in the 64\dash bit DWARF format,
+is an unsigned 32-bit integer (which
+must be less than \xfffffffzero); in the 64-bit DWARF format,
 an \addtoindex{initial length} field is 96 bits in size,
 and has two parts:
 \begin{itemize}
-\item The first 32\dash bits have the value \xffffffff.
+\item The first 32-bits have the value \xffffffff.
 
-\item  The following 64\dash bits contain the actual length
-represented as an unsigned 64\dash bit integer.
+\item  The following 64-bits contain the actual length
+represented as an unsigned 64-bit integer.
 \end{itemize}
 
 \textit{This representation allows a DWARF consumer to dynamically
-detect that a DWARF section contribution is using the 64\dash bit
+detect that a DWARF section contribution is using the 64-bit
 format and to adapt its processing accordingly.}
 
+\needlines{4}
 \item Section offset and section length
 \hypertarget{datarep:sectionoffsetlength}{} 
 \addtoindexx{section length!use in headers}
@@ -650,9 +674,9 @@ fields that occur
 \addtoindexx{section offset!use in headers}
 in the headers of DWARF sections (other than initial length
 \addtoindexx{initial length}
-fields) are listed following. In the 32\dash bit DWARF format these
-are 32\dash bit unsigned integer values; in the 64\dash bit DWARF format,
-they are 64\dash bit unsigned integer values.
+fields) are listed following. In the 32-bit DWARF format these
+are 32-bit unsigned integer values; in the 64-bit DWARF format,
+they are 64-bit unsigned integer values.
 
 \begin{center}
 \begin{tabular}{lll}
@@ -676,9 +700,9 @@ each other (both offset and size).
 
 \item Within the body of the \dotdebuginfo{}
 section, certain forms of attribute value depend on the choice
-of DWARF format as follows. For the 32\dash bit DWARF format,
-the value is a 32\dash bit unsigned integer; for the 64\dash bit DWARF
-format, the value is a 64\dash bit unsigned integer.
+of DWARF format as follows. For the 32-bit DWARF format,
+the value is a 32-bit unsigned integer; for the 64-bit DWARF
+format, the value is a 64-bit unsigned integer.
 \begin{center}
 \begin{tabular}{lp{6cm}}
 Form             & Role  \\ \hline
@@ -712,8 +736,8 @@ compilation units (CUs) and the array of local type units
 (TUs), which represents an offset in the 
 \dotdebuginfo{}
 section, depends on the DWARF format as follows: in the
-32\dash bit DWARF format, each entry is a 32\dash bit unsigned integer;
-in the 64\dash bit DWARF format, it is a 64\dash bit unsigned integer.
+32-bit DWARF format, each entry is a 32-bit unsigned integer;
+in the 64-bit DWARF format, it is a 64-bit unsigned integer.
 
 \needlines{4}
 \item In the body of the \dotdebugstroffsets{} and \dotdebugstroffsetsdwo{}
@@ -729,31 +753,31 @@ contain 4; in the 64-bit DWARF format these fields contain 8.
 \end{enumerate}
 
 
-The 32\dash bit and 64\dash bit DWARF format conventions must \emph{not} be
+The 32-bit and 64-bit DWARF format conventions must \emph{not} be
 intermixed within a single compilation unit.
 
 \textit{Attribute values and section header fields that represent
 addresses in the target program are not affected by these
 rules.}
 
-A DWARF consumer that supports the 64\dash bit DWARF format must
+A DWARF consumer that supports the 64-bit DWARF format must
 support executables in which some compilation units use the
-32\dash bit format and others use the 64\dash bit format provided that
+32-bit format and others use the 64-bit format provided that
 the combination links correctly (that is, provided that there
 are no link\dash time errors due to truncation or overflow). (An
 implementation is not required to guarantee detection and
 reporting of all such errors.)
 
 \textit{It is expected that DWARF producing compilers will \emph{not} use
-the 64\dash bit format \emph{by default}. In most cases, the division of
+the 64-bit format \emph{by default}. In most cases, the division of
 even very large applications into a number of executable and
 shared objects will suffice to assure that the DWARF sections
 within each individual linked object are less than 4 GBytes
-in size. However, for those cases where needed, the 64\dash bit
+in size. However, for those cases where needed, the 64-bit
 format allows the unusual case to be handled as well. Even
 in this case, it is expected that only application supplied
-objects will need to be compiled using the 64\dash bit format;
-separate 32\dash bit format versions of system supplied shared
+objects will need to be compiled using the 64-bit format;
+separate 32-bit format versions of system supplied shared
 executable libraries can still be used.}
 
 
@@ -831,27 +855,27 @@ enumeration are shown in Table \refersec{tab:unitheaderunitkindencodings}.
 
 \item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
 \addttindexx{unit\_length}
-A 4\dash byte or 12\dash byte 
+A 4-byte or 12-byte 
 \addtoindexx{initial length}
 unsigned integer representing the length
 of the \dotdebuginfo{}
 contribution for that compilation unit,
 not including the length field itself. In the \thirtytwobitdwarfformat,
- this is a 4\dash byte unsigned integer (which must be less
+ this is a 4-byte unsigned integer (which must be less
 than \xfffffffzero); in the \sixtyfourbitdwarfformat, this consists
-of the 4\dash byte value \wffffffff followed by an 8\dash byte unsigned
+of the 4-byte value \wffffffff followed by an 8-byte unsigned
 integer that gives the actual length 
 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
 
-\item  \texttt{version} (\addtoindex{uhalf}) \\
+\item  \texttt{version} (\HFTuhalf) \\
 \addttindexx{version}
-A 2\dash byte unsigned integer representing the version of the
+A 2-byte unsigned integer representing the version of the
 DWARF information for the compilation unit \addtoindexx{version number!compilation unit} 
 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}). 
 The value in this field is \versiondotdebuginfo.
 
 \needlines{4}
-\item \texttt{unit\_type} (\addtoindex{ubyte}) \\
+\item \texttt{unit\_type} (\HFTubyte) \\
 \addttindexx{unit\_type}
 A 1-byte unsigned integer identifying this unit as a compilation unit.
 The value of this field is 
@@ -866,17 +890,17 @@ The value of this field is
 \addttindexx{debug\_abbrev\_offset}
 A 
 \addtoindexx{section offset!in .debug\_info header}
-4\dash byte or 8\dash byte unsigned offset into the 
+4-byte or 8-byte unsigned offset into the 
 \dotdebugabbrev{}
 section. This offset associates the compilation unit with a
 particular set of debugging information entry abbreviations. In
-the \thirtytwobitdwarfformat, this is a 4\dash byte unsigned length;
-in the \sixtyfourbitdwarfformat, this is an 8\dash byte unsigned length
+the \thirtytwobitdwarfformat, this is a 4-byte unsigned length;
+in the \sixtyfourbitdwarfformat, this is an 8-byte unsigned length
 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
 
-\item \texttt{address\_size} (\addtoindex{ubyte}) \\
+\item \texttt{address\_size} (\HFTubyte) \\
 \addttindexx{address\_size}
-A 1\dash byte unsigned integer representing the size in bytes of
+A 1-byte unsigned integer representing the size in bytes of
 an address on the target architecture. If the system uses
 \addtoindexx{address space!segmented}
 segmented addressing, this value represents the size of the
@@ -896,27 +920,27 @@ consists of the following information:
 
 \item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
 \addttindexx{unit\_length}
-A 4\dash byte or 12\dash byte unsigned integer 
+A 4-byte or 12-byte unsigned integer 
 \addtoindexx{initial length}
 representing the length
 of the \dotdebuginfo{} contribution for that type unit,
 not including the length field itself. In the \thirtytwobitdwarfformat, 
-this is a 4\dash byte unsigned integer (which must be
+this is a 4-byte unsigned integer (which must be
 less than \xfffffffzero); in the \sixtyfourbitdwarfformat, this
-consists of the 4\dash byte value \wffffffff followed by an 
-8\dash byte unsigned integer that gives the actual length
+consists of the 4-byte value \wffffffff followed by an 
+8-byte unsigned integer that gives the actual length
 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
 
 \needlines{4}
-\item  \texttt{version} (\addtoindex{uhalf}) \\
+\item  \texttt{version} (\HFTuhalf) \\
 \addttindexx{version}
-A 2\dash byte unsigned integer representing the version of the
+A 2-byte unsigned integer representing the version of the
 DWARF information for the 
 type unit\addtoindexx{version number!type unit} 
 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}). 
 The value in this field is \versiondotdebuginfo.
 
-\item \texttt{unit\_type} (\addtoindex{ubyte}) \\
+\item \texttt{unit\_type} (\HFTubyte) \\
 \addttindexx{unit\_type}
 A 1-byte unsigned integer identifying this unit as a type unit.
 The value of this field is \DWUTtype{} for a type unit
@@ -929,18 +953,18 @@ The value of this field is \DWUTtype{} for a type unit
 \addttindexx{debug\_abbrev\_offset}
 A 
 \addtoindexx{section offset!in .debug\_info header}
-4\dash byte or 8\dash byte unsigned offset into the 
+4-byte or 8-byte unsigned offset into the 
 \dotdebugabbrev{}
 section. This offset associates the type unit with a
 particular set of debugging information entry abbreviations. In
-the \thirtytwobitdwarfformat, this is a 4\dash byte unsigned length;
-in the \sixtyfourbitdwarfformat, this is an 8\dash byte unsigned length
+the \thirtytwobitdwarfformat, this is a 4-byte unsigned length;
+in the \sixtyfourbitdwarfformat, this is an 8-byte unsigned length
 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
 
 \needlines{4}
-\item \texttt{address\_size} (\addtoindex{ubyte}) \\
+\item \texttt{address\_size} (\HFTubyte) \\
 \addttindexx{address\_size}
-A 1\dash byte unsigned integer representing the size 
+A 1-byte unsigned integer representing the size 
 \addtoindexx{size of an address}
 in bytes of
 an address on the target architecture. If the system uses
@@ -948,10 +972,10 @@ an address on the target architecture. If the system uses
 segmented addressing, this value represents the size of the
 offset portion of an address.
 
-\item \texttt{type\_signature} (8\dash byte unsigned integer) \\
+\item \texttt{type\_signature} (8-byte unsigned integer) \\
 \addttindexx{type\_signature}
 \addtoindexx{type signature}
-A 64\dash bit unique signature (see Section 
+A 64-bit unique signature (see Section 
 \refersec{datarep:typesignaturecomputation})
 of the type described in this type
 unit.  
@@ -963,7 +987,7 @@ the primary type contained in this
 
 \item \texttt{type\_offset} (\livelink{datarep:sectionoffsetlength}{section offset}) \\
 \addttindexx{type\_offset}
-A 4\dash byte or 8\dash byte unsigned offset 
+A 4-byte or 8-byte unsigned offset 
 \addtoindexx{section offset!in .debug\_info header}
 relative to the beginning
 of the \addtoindex{type unit} header.
@@ -973,8 +997,8 @@ may be nested inside a namespace or other structures, and may
 contain references to other types that have not been placed in
 separate type units, it is not necessarily either the first or
 the only entry in the type unit. In the \thirtytwobitdwarfformat,
-this is a 4\dash byte unsigned length; in the \sixtyfourbitdwarfformat,
-this is an 8\dash byte unsigned length
+this is a 4-byte unsigned length; in the \sixtyfourbitdwarfformat,
+this is an 8-byte unsigned length
 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
 
 \end{enumerate}
@@ -1105,13 +1129,13 @@ Table \refersec{tab:tagencodings}.
 \end{longtable}
 \end{centering}
 
-Following the tag encoding is a 1\dash byte value that determines
+Following the tag encoding is a 1-byte value that determines
 whether a debugging information entry using this abbreviation
 has child entries or not. If the value is 
 \DWCHILDRENyesTARG,
 the next physically succeeding entry of any debugging
 information entry using this abbreviation is the first
-child of that entry. If the 1\dash byte value following the
+child of that entry. If the 1-byte value following the
 abbreviation\textquoteright s tag encoding is 
 \DWCHILDRENnoTARG, the next
 physically succeeding entry of any debugging information entry
@@ -1180,445 +1204,12 @@ Appendix \refersec{app:compilationunitsandabbreviationstableexample}
 for a depiction of the organization of the
 debugging information.}
 
-
+\needlines{12}
 \subsection{Attribute Encodings}
 \label{datarep:attributeencodings}
 
 The encodings for the attribute names are given in 
-Table \refersec{tab:attributeencodings}.
-
-The attribute form governs how the value of the attribute is
-encoded. There are nine classes of form, listed below. Each
-class is a set of forms which have related representations
-and which are given a common interpretation according to the
-attribute in which the form is used.
-
-Form \DWFORMsecoffsetTARG{} 
-is a member of more 
-\addtoindexx{rangelistptr class}
-than 
-\addtoindexx{macptr class}
-one 
-\addtoindexx{loclistptr class}
-class,
-\addtoindexx{lineptr class}
-namely 
-\CLASSaddrptr, 
-\CLASSlineptr, 
-\CLASSloclistptr, 
-\CLASSmacptr,  
-\CLASSrangelistptr{} or
-\CLASSstroffsetsptr; 
-the list of classes allowed by the applicable attribute in 
-Table \refersec{tab:attributeencodings}
-determines the class of the form.
-
-
-\needlines{4}
-Each possible form belongs to one or more of the following classes:
-
-\begin{itemize}
-\item \livelinki{chap:classaddress}{address}{address class} \\
-\livetarg{datarep:classaddress}{}
-Represented as either:
-\begin{itemize}
-\item An object of appropriate size to hold an
-address on the target machine 
-(\DWFORMaddrTARG). 
-The size is encoded in the compilation unit header 
-(see Section \refersec{datarep:compilationunitheader}).
-This address is relocatable in a relocatable object file and
-is relocated in an executable file or shared object.
-
-\item An indirect index into a table of addresses (as 
-described in the previous bullet) in the
-\dotdebugaddr{} section (\DWFORMaddrxTARG). 
-The representation of a \DWFORMaddrxNAME{} value is an unsigned
-\addtoindex{LEB128} value, which is interpreted as a zero-based 
-index into an array of addresses in the \dotdebugaddr{} section.
-The index is relative to the value of the \DWATaddrbase{} attribute 
-of the associated compilation unit.
-\end{itemize}
-
-\needlines{5}
-\item \livelink{chap:classaddrptr}{addrptr} \\
-\livetarg{datarep:classaddrptr}{}
-This is an offset into the \dotdebugaddr{} section (\DWFORMsecoffset). It
-consists of an offset from the beginning of the \dotdebugaddr{} section to the
-beginning of the list of machine addresses information for the
-referencing entity. It is relocatable in
-a relocatable object file, and relocated in an executable or
-shared object. In the \thirtytwobitdwarfformat, this offset
-is a 4\dash byte unsigned value; in the 64\dash bit DWARF
-format, it is an 8\dash byte unsigned value (see Section
-\refersec{datarep:32bitand64bitdwarfformats}).
-
-\textit{This class is new in \DWARFVersionV.}
-
-\needlines{4}
-\item \livelink{chap:classblock}{block} \\
-\livetarg{datarep:classblock}{}
-Blocks come in four forms:
-
-\begin{myindentpara}{1cm}
-A 1\dash byte length followed by 0 to 255 contiguous information
-bytes (\DWFORMblockoneTARG).
-\end{myindentpara}
-
-\begin{myindentpara}{1cm}
-A 2\dash byte length followed by 0 to 65,535 contiguous information
-bytes (\DWFORMblocktwoTARG).
-\end{myindentpara}
-
-\begin{myindentpara}{1cm}
-A 4\dash byte length followed by 0 to 4,294,967,295 contiguous
-information bytes (\DWFORMblockfourTARG).
-\end{myindentpara}
-
-\begin{myindentpara}{1cm}
-An unsigned LEB128\addtoindexx{LEB128!unsigned}
-length followed by the number of bytes
-specified by the length (\DWFORMblockTARG).
-\end{myindentpara}
-
-In all forms, the length is the number of information bytes
-that follow. The information bytes may contain any mixture
-of relocated (or relocatable) addresses, references to other
-debugging information entries or data bytes.
-
-\item \livelinki{chap:classconstant}{constant}{constant class} \\
-\livetarg{datarep:classconstant}{}
-There are eight forms of constants. There are fixed length
-constant data forms for one-, two-, four-, eight- and sixteen-byte values
-(respectively, 
-\DWFORMdataoneTARG, 
-\DWFORMdatatwoTARG, 
-\DWFORMdatafourTARG,
-\DWFORMdataeightTARG{} and
-\DWFORMdatasixteenTARG). 
-There are also variable length constant
-data forms encoded using LEB128 numbers (see below). 
-Both signed (\DWFORMsdataTARG) and unsigned 
-(\DWFORMudataTARG) variable length constants are available.
-There is also an implicit constant (\DWFORMimplicitconst),
-whose value is provided as part of the abbreviation
-declaration.
-
-\needlines{4}
-The data in \DWFORMdataone, 
-\DWFORMdatatwo, 
-\DWFORMdatafour{}, 
-\DWFORMdataeight{} and
-\DWFORMdatasixteen{} 
-can be anything. Depending on context, it may
-be a signed integer, an unsigned integer, a floating\dash point
-constant, or anything else. A consumer must use context to
-know how to interpret the bits, which if they are target
-machine data (such as an integer or floating point constant)
-will be in target machine byte\dash order.
-
-\textit{If one of the \DWFORMdataTARG\textless n\textgreater 
-forms is used to represent a
-signed or unsigned integer, it can be hard for a consumer
-to discover the context necessary to determine which
-interpretation is intended. Producers are therefore strongly
-encouraged to use \DWFORMsdata{} or 
-\DWFORMudata{} for signed and
-unsigned integers respectively, rather than 
-\DWFORMdata\textless n\textgreater.}
-
-\needlines{4}
-\item \livelinki{chap:classexprloc}{exprloc}{exprloc class} \\
-\livetarg{datarep:classexprloc}{}
-This is an unsigned LEB128\addtoindexx{LEB128!unsigned} length followed by the
-number of information bytes specified by the length
-(\DWFORMexprlocTARG). 
-The information bytes contain a DWARF expression 
-(see Section \refersec{chap:dwarfexpressions}) 
-or location description 
-(see Section \refersec{chap:locationdescriptions}).
-
-\item \livelinki{chap:classflag}{flag}{flag class} \\
-\livetarg{datarep:classflag}{}
-A flag \addtoindexx{flag class}
-is represented explicitly as a single byte of data
-(\DWFORMflagTARG) or 
-implicitly (\DWFORMflagpresentTARG). 
-In the
-first case, if the \nolink{flag} has value zero, it indicates the
-absence of the attribute; if the \nolink{flag} has a non\dash zero value,
-it indicates the presence of the attribute. In the second
-case, the attribute is implicitly indicated as present, and
-no value is encoded in the debugging information entry itself.
-
-\item \livelinki{chap:classlineptr}{lineptr}{lineptr class} \\
-\livetarg{datarep:classlineptr}{}
-This is an offset into 
-\addtoindexx{section offset!in class lineptr value}
-the 
-\dotdebugline{} or \dotdebuglinedwo{} section
-(\DWFORMsecoffset).
-It consists of an offset from the beginning of the 
-\dotdebugline{}
-section to the first byte of
-the data making up the line number list for the compilation
-unit. 
-It is relocatable in a relocatable object file, and
-relocated in an executable or shared object. In the 
-\thirtytwobitdwarfformat, this offset is a 4\dash byte unsigned value;
-in the \sixtyfourbitdwarfformat, it is an 8\dash byte unsigned value
-(see Section \refersec{datarep:32bitand64bitdwarfformats}).
-
-
-\item \livelinki{chap:classloclistptr}{loclistptr}{loclistptr class} \\
-\livetarg{datarep:classloclistptr}{}
-This is an offset into the 
-\dotdebugloc{}
-section
-(\DWFORMsecoffset). 
-It consists of an offset from the
-\addtoindexx{section offset!in class loclistptr value}
-beginning of the 
-\dotdebugloc{}
-section to the first byte of
-the data making up the 
-\addtoindex{location list} for the compilation unit. 
-It is relocatable in a relocatable object file, and
-relocated in an executable or shared object. In the 
-\thirtytwobitdwarfformat, this offset is a 4\dash byte unsigned value;
-in the \sixtyfourbitdwarfformat, it is an 8\dash byte unsigned value
-(see Section \refersec{datarep:32bitand64bitdwarfformats}).
-
-
-\item \livelinki{chap:classmacptr}{macptr}{macptr class} \\
-\livetarg{datarep:classmacptr}{}
-This is an 
-\addtoindexx{section offset!in class macptr value}
-offset into the 
-\dotdebugmacro{} or \dotdebugmacrodwo{} section
-(\DWFORMsecoffset). 
-It consists of an offset from the beginning of the 
-\dotdebugmacro{} or \dotdebugmacrodwo{} 
-section to the the header making up the 
-macro information list for the compilation unit. 
-It is relocatable in a relocatable object file, and
-relocated in an executable or shared object. In the 
-\thirtytwobitdwarfformat, this offset is a 4\dash byte unsigned value;
-in the \sixtyfourbitdwarfformat, it is an 8\dash byte unsigned value
-(see Section \refersec{datarep:32bitand64bitdwarfformats}).
-
-\needlines{4}
-\item \livelinki{chap:classrangelistptr}{rangelistptr}{rangelistptr class} \\
-\livetarg{datarep:classrangelistptr}{}
-This is an 
-\addtoindexx{section offset!in class rangelistptr value}
-offset into the \dotdebugranges{} section
-(\DWFORMsecoffset). 
-It consists of an
-offset from the beginning of the 
-\dotdebugranges{} section
-to the beginning of the non\dash contiguous address ranges
-information for the referencing entity.  
-It is relocatable in
-a relocatable object file, and relocated in an executable or
-shared object. In the \thirtytwobitdwarfformat, this offset
-is a 4\dash byte unsigned value; in the 64\dash bit DWARF
-format, it is an 8\dash byte unsigned value (see Section
-\refersec{datarep:32bitand64bitdwarfformats}).
-\end{itemize}
-
-\textit{Because classes
-\CLASSaddrptr, 
-\CLASSlineptr, 
-\CLASSloclistptr, 
-\CLASSmacptr, 
-\CLASSrangelistptr{} and
-\CLASSstroffsetsptr{}
-share a common representation, it is not possible for an
-attribute to allow more than one of these classes}
-
-
-\begin{itemize}
-\item \livelinki{chap:classreference}{reference}{reference class} \\
-\livetarg{datarep:classreference}{}
-There are four types of reference.
-
-The 
-\addtoindexx{reference class}
-first type of reference can identify any debugging
-information entry within the containing unit. 
-This type of
-reference is an 
-\addtoindexx{section offset!in class reference value}
-offset from the first byte of the compilation
-header for the compilation unit containing the reference. There
-are five forms for this type of reference. There are fixed
-length forms for one, two, four and eight byte offsets
-(respectively,
-\DWFORMrefnMARK 
-\DWFORMrefoneTARG, 
-\DWFORMreftwoTARG, 
-\DWFORMreffourTARG,
-and \DWFORMrefeightTARG). 
-There is also an unsigned variable
-length offset encoded form that uses 
-unsigned LEB128\addtoindexx{LEB128!unsigned} numbers
-(\DWFORMrefudataTARG). 
-Because this type of reference is within
-the containing compilation unit no relocation of the value
-is required.
-
-The second type of reference can identify any debugging
-information entry within a 
-\dotdebuginfo{} section; in particular,
-it may refer to an entry in a different compilation unit
-from the unit containing the reference, and may refer to an
-entry in a different shared object.  This type of reference
-(\DWFORMrefaddrTARG) 
-is an offset from the beginning of the
-\dotdebuginfo{} 
-section of the target executable or shared object, or, for
-references within a \addtoindex{supplementary object file}, 
-an offset from the beginning of the local \dotdebuginfo{} section;
-it is relocatable in a relocatable object file and frequently
-relocated in an executable file or shared object. For
-references from one shared object or static executable file
-to another, the relocation and identification of the target
-object must be performed by the consumer. In the 
-\thirtytwobitdwarfformat, this offset is a 4\dash byte unsigned value; 
-in the \sixtyfourbitdwarfformat, it is an 8\dash byte
-unsigned value 
-(see Section \refersec{datarep:32bitand64bitdwarfformats}).
-
-\textit{A debugging information entry that may be referenced by
-another compilation unit using 
-\DWFORMrefaddr{} must have a global symbolic name.}
-
-\textit{For a reference from one executable or shared object to
-another, the reference is resolved by the debugger to identify
-the shared object or executable and the offset into that
-object\textquoteright s \dotdebuginfo{}
-section in the same fashion as the run
-time loader, either when the debug information is first read,
-or when the reference is used.}
-
-The third type of reference can identify any debugging
-information type entry that has been placed in its own
-\addtoindex{type unit}. This type of 
-reference (\DWFORMrefsigeightTARG) is the
-\addtoindexx{type signature}
-64\dash bit type signature 
-(see Section \refersec{datarep:typesignaturecomputation}) 
-that was computed for the type. 
-
-The fourth type of reference is a reference from within the 
-\dotdebuginfo{} section of the executable or shared object to
-a debugging information entry in the \dotdebuginfo{} section of 
-a \addtoindex{supplementary object file}.
-This type of reference (\DWFORMrefsupTARG) is an offset from the 
-beginning of the \dotdebuginfo{} section in the supplementary 
-object file.
-
-\textit{The use of compilation unit relative references will reduce the
-number of link\dash time relocations and so speed up linking. The
-use of the second, third and fourth type of reference allows for the
-sharing of information, such as types, across compilation
-units, while the fourth type further allows for sharing of information 
-across compilation units from different executables or shared objects.}
-
-\textit{A reference to any kind of compilation unit identifies the
-debugging information entry for that unit, not the preceding
-header.}
-
-\needlines{4}
-\item \livelinki{chap:classstring}{string}{string class} \\
-\livetarg{datarep:classstring}{}
-A string is a sequence of contiguous non\dash null bytes followed by
-one null byte. 
-\addtoindexx{string class}
-A string may be represented: 
-\begin{itemize}
-\setlength{\itemsep}{0em}
-\item immediately in the debugging information entry itself 
-(\DWFORMstringTARG), 
-
-\item as an 
-\addtoindexx{section offset!in class string value}
-offset into a string table contained in
-the \dotdebugstr{} section of the object file (\DWFORMstrpTARG), 
-the \dotdebuglinestr{} section of the object file (\DWFORMlinestrpTARG),
-or as an offset into a string table contained in the
-\dotdebugstr{} section of a \addtoindex{supplementary object file} 
-(\DWFORMstrpsupTARG).  \DWFORMstrpsupNAME{} offsets from the \dotdebuginfo{}  
-section of a \addtoindex{supplementary object file}
-refer to the local \dotdebugstr{} section of that same file.
-In the \thirtytwobitdwarfformat, the representation of a 
-\DWFORMstrpNAME{}, \DWFORMstrpNAME{} or \DWFORMstrpsupNAME{}
-value is a 4\dash byte unsigned offset; in the \sixtyfourbitdwarfformat,
-it is an 8\dash byte unsigned offset 
-(see Section \refersec{datarep:32bitand64bitdwarfformats}).
-
-\item as an indirect offset into the string table using an 
-index into a table of offsets contained in the 
-\dotdebugstroffsets{} section of the object file (\DWFORMstrxTARG).
-The representation of a \DWFORMstrxNAME{} value is an unsigned 
-\addtoindex{LEB128} value, which is interpreted as a zero-based 
-index into an array of offsets in the \dotdebugstroffsets{} section. 
-The offset entries in the \dotdebugstroffsets{} section have the 
-same representation as \DWFORMstrp{} values.
-\end{itemize}
-Any combination of these three forms may be used within a single compilation.
-
-If the \DWATuseUTFeight{}
-\addtoindexx{use UTF8 attribute}\addtoindexx{UTF-8} attribute is specified for the
-compilation, partial, skeleton or type unit entry, string values are encoded using the
-UTF\dash 8 (\addtoindex{Unicode} Transformation Format\dash 8) from the Universal
-Character Set standard (ISO/IEC 10646\dash 1:1993).
-\addtoindexx{ISO 10646 character set standard}
-Otherwise, the string representation is unspecified.
-
-\textit{The \addtoindex{Unicode} Standard Version 3 is fully compatible with
-ISO/IEC 10646\dash 1:1993. 
-\addtoindexx{ISO 10646 character set standard}
-It contains all the same characters
-and encoding points as ISO/IEC 10646, as well as additional
-information about the characters and their use.}
-
-\textit{Earlier versions of DWARF did not specify the representation
-of strings; for compatibility, this version also does
-not. However, the UTF\dash 8 representation is strongly recommended.}
-
-\needlines{4}
-\item \livelinki{chap:classstroffsetsptr}{stroffsetsptr}{stroffsetsptr class} \\
-\livetarg{datarep:classstroffsetsptr}{}
-This is an offset into the \dotdebugstroffsets{} section 
-(\DWFORMsecoffset). It consists of an offset from the beginning of the 
-\dotdebugstroffsets{} section to the
-beginning of the string offsets information for the
-referencing entity. It is relocatable in
-a relocatable object file, and relocated in an executable or
-shared object. In the \thirtytwobitdwarfformat, this offset
-is a 4\dash byte unsigned value; in the 64\dash bit DWARF
-format, it is an 8\dash byte unsigned value (see Section
-\refersec{datarep:32bitand64bitdwarfformats}).
-
-\textit{This class is new in \DWARFVersionV.}
-
-\end{itemize}
-
-In no case does an attribute use one of the classes 
-\CLASSaddrptr,
-\CLASSlineptr,
-\CLASSloclistptr, 
-\CLASSmacptr, 
-\CLASSrangelistptr{} or 
-\CLASSstroffsetsptr{}
-to point into either the
-\dotdebuginfo{} or \dotdebugstr{} section.
-
-The form encodings are listed in 
-Table \refersec{tab:attributeformencodings}.
-
+Table \referfol{tab:attributeencodings}.
 
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
@@ -1933,8 +1524,441 @@ Table \refersec{tab:attributeformencodings}.
 \DWATlouser&0x2000 & --- \addtoindexx{low user attribute encoding}  \\
 \DWAThiuser&\xiiifff& --- \addtoindexx{high user attribute encoding}  \\
 
-\end{longtable} 
-\end{centering}
+\end{longtable} 
+\end{centering}
+
+The attribute form governs how the value of the attribute is
+encoded. There are nine classes of form, listed below. Each
+class is a set of forms which have related representations
+and which are given a common interpretation according to the
+attribute in which the form is used.
+
+Form \DWFORMsecoffsetTARG{} 
+is a member of more 
+\addtoindexx{rangelistptr class}
+than 
+\addtoindexx{macptr class}
+one 
+\addtoindexx{loclistptr class}
+class,
+\addtoindexx{lineptr class}
+namely 
+\CLASSaddrptr, 
+\CLASSlineptr, 
+\CLASSloclistptr, 
+\CLASSmacptr,  
+\CLASSrangelistptr{} or
+\CLASSstroffsetsptr; 
+the list of classes allowed by the applicable attribute in 
+Table \refersec{tab:attributeencodings}
+determines the class of the form.
+
+
+\needlines{4}
+Each possible form belongs to one or more of the following classes:
+
+\begin{itemize}
+\item \livelinki{chap:classaddress}{address}{address class} \\
+\livetarg{datarep:classaddress}{}
+Represented as either:
+\begin{itemize}
+\item An object of appropriate size to hold an
+address on the target machine 
+(\DWFORMaddrTARG). 
+The size is encoded in the compilation unit header 
+(see Section \refersec{datarep:compilationunitheader}).
+This address is relocatable in a relocatable object file and
+is relocated in an executable file or shared object.
+
+\item An indirect index into a table of addresses (as 
+described in the previous bullet) in the
+\dotdebugaddr{} section (\DWFORMaddrxTARG). 
+The representation of a \DWFORMaddrxNAME{} value is an unsigned
+\addtoindex{LEB128} value, which is interpreted as a zero-based 
+index into an array of addresses in the \dotdebugaddr{} section.
+The index is relative to the value of the \DWATaddrbase{} attribute 
+of the associated compilation unit.
+\end{itemize}
+
+\needlines{5}
+\item \livelink{chap:classaddrptr}{addrptr} \\
+\livetarg{datarep:classaddrptr}{}
+This is an offset into the \dotdebugaddr{} section (\DWFORMsecoffset). It
+consists of an offset from the beginning of the \dotdebugaddr{} section to the
+beginning of the list of machine addresses information for the
+referencing entity. It is relocatable in
+a relocatable object file, and relocated in an executable or
+shared object. In the \thirtytwobitdwarfformat, this offset
+is a 4-byte unsigned value; in the 64-bit DWARF
+format, it is an 8-byte unsigned value (see Section
+\refersec{datarep:32bitand64bitdwarfformats}).
+
+\textit{This class is new in \DWARFVersionV.}
+
+\needlines{4}
+\item \livelink{chap:classblock}{block} \\
+\livetarg{datarep:classblock}{}
+Blocks come in four forms:
+
+\begin{myindentpara}{1cm}
+A 1-byte length followed by 0 to 255 contiguous information
+bytes (\DWFORMblockoneTARG).
+\end{myindentpara}
+
+\begin{myindentpara}{1cm}
+A 2-byte length followed by 0 to 65,535 contiguous information
+bytes (\DWFORMblocktwoTARG).
+\end{myindentpara}
+
+\begin{myindentpara}{1cm}
+A 4-byte length followed by 0 to 4,294,967,295 contiguous
+information bytes (\DWFORMblockfourTARG).
+\end{myindentpara}
+
+\begin{myindentpara}{1cm}
+An unsigned LEB128\addtoindexx{LEB128!unsigned}
+length followed by the number of bytes
+specified by the length (\DWFORMblockTARG).
+\end{myindentpara}
+
+In all forms, the length is the number of information bytes
+that follow. The information bytes may contain any mixture
+of relocated (or relocatable) addresses, references to other
+debugging information entries or data bytes.
+
+\item \livelinki{chap:classconstant}{constant}{constant class} \\
+\livetarg{datarep:classconstant}{}
+There are eight forms of constants. There are fixed length
+constant data forms for one-, two-, four-, eight- and sixteen-byte values
+(respectively, 
+\DWFORMdataoneTARG, 
+\DWFORMdatatwoTARG, 
+\DWFORMdatafourTARG,
+\DWFORMdataeightTARG{} and
+\DWFORMdatasixteenTARG). 
+There are also variable length constant
+data forms encoded using LEB128 numbers (see below). 
+Both signed (\DWFORMsdataTARG) and unsigned 
+(\DWFORMudataTARG) variable length constants are available.
+There is also an implicit constant (\DWFORMimplicitconst),
+whose value is provided as part of the abbreviation
+declaration.
+
+\needlines{4}
+The data in \DWFORMdataone, 
+\DWFORMdatatwo, 
+\DWFORMdatafour{}, 
+\DWFORMdataeight{} and
+\DWFORMdatasixteen{} 
+can be anything. Depending on context, it may
+be a signed integer, an unsigned integer, a floating\dash point
+constant, or anything else. A consumer must use context to
+know how to interpret the bits, which if they are target
+machine data (such as an integer or floating point constant)
+will be in target machine byte\dash order.
+
+\textit{If one of the \DWFORMdataTARG\textless n\textgreater 
+forms is used to represent a
+signed or unsigned integer, it can be hard for a consumer
+to discover the context necessary to determine which
+interpretation is intended. Producers are therefore strongly
+encouraged to use \DWFORMsdata{} or 
+\DWFORMudata{} for signed and
+unsigned integers respectively, rather than 
+\DWFORMdata\textless n\textgreater.}
+
+\needlines{4}
+\item \livelinki{chap:classexprloc}{exprloc}{exprloc class} \\
+\livetarg{datarep:classexprloc}{}
+This is an unsigned LEB128\addtoindexx{LEB128!unsigned} length followed by the
+number of information bytes specified by the length
+(\DWFORMexprlocTARG). 
+The information bytes contain a DWARF expression 
+(see Section \refersec{chap:dwarfexpressions}) 
+or location description 
+(see Section \refersec{chap:locationdescriptions}).
+
+\item \livelinki{chap:classflag}{flag}{flag class} \\
+\livetarg{datarep:classflag}{}
+A flag \addtoindexx{flag class}
+is represented explicitly as a single byte of data
+(\DWFORMflagTARG) or 
+implicitly (\DWFORMflagpresentTARG). 
+In the
+first case, if the \nolink{flag} has value zero, it indicates the
+absence of the attribute; if the \nolink{flag} has a non\dash zero value,
+it indicates the presence of the attribute. In the second
+case, the attribute is implicitly indicated as present, and
+no value is encoded in the debugging information entry itself.
+
+\item \livelinki{chap:classlineptr}{lineptr}{lineptr class} \\
+\livetarg{datarep:classlineptr}{}
+This is an offset into 
+\addtoindexx{section offset!in class lineptr value}
+the 
+\dotdebugline{} or \dotdebuglinedwo{} section
+(\DWFORMsecoffset).
+It consists of an offset from the beginning of the 
+\dotdebugline{}
+section to the first byte of
+the data making up the line number list for the compilation
+unit. 
+It is relocatable in a relocatable object file, and
+relocated in an executable or shared object. In the 
+\thirtytwobitdwarfformat, this offset is a 4-byte unsigned value;
+in the \sixtyfourbitdwarfformat, it is an 8-byte unsigned value
+(see Section \refersec{datarep:32bitand64bitdwarfformats}).
+
+
+\item \livelinki{chap:classloclistptr}{loclistptr}{loclistptr class} \\
+\livetarg{datarep:classloclistptr}{}
+This is an offset into the 
+\dotdebugloc{}
+section
+(\DWFORMsecoffset). 
+It consists of an offset from the
+\addtoindexx{section offset!in class loclistptr value}
+beginning of the 
+\dotdebugloc{}
+section to the first byte of
+the data making up the 
+\addtoindex{location list} for the compilation unit. 
+It is relocatable in a relocatable object file, and
+relocated in an executable or shared object. In the 
+\thirtytwobitdwarfformat, this offset is a 4-byte unsigned value;
+in the \sixtyfourbitdwarfformat, it is an 8-byte unsigned value
+(see Section \refersec{datarep:32bitand64bitdwarfformats}).
+
+
+\item \livelinki{chap:classmacptr}{macptr}{macptr class} \\
+\livetarg{datarep:classmacptr}{}
+This is an 
+\addtoindexx{section offset!in class macptr value}
+offset into the 
+\dotdebugmacro{} or \dotdebugmacrodwo{} section
+(\DWFORMsecoffset). 
+It consists of an offset from the beginning of the 
+\dotdebugmacro{} or \dotdebugmacrodwo{} 
+section to the the header making up the 
+macro information list for the compilation unit. 
+It is relocatable in a relocatable object file, and
+relocated in an executable or shared object. In the 
+\thirtytwobitdwarfformat, this offset is a 4-byte unsigned value;
+in the \sixtyfourbitdwarfformat, it is an 8-byte unsigned value
+(see Section \refersec{datarep:32bitand64bitdwarfformats}).
+
+\needlines{4}
+\item \livelinki{chap:classrangelistptr}{rangelistptr}{rangelistptr class} \\
+\livetarg{datarep:classrangelistptr}{}
+This is an 
+\addtoindexx{section offset!in class rangelistptr value}
+offset into the \dotdebugranges{} section
+(\DWFORMsecoffset). 
+It consists of an
+offset from the beginning of the 
+\dotdebugranges{} section
+to the beginning of the non\dash contiguous address ranges
+information for the referencing entity.  
+It is relocatable in
+a relocatable object file, and relocated in an executable or
+shared object. In the \thirtytwobitdwarfformat, this offset
+is a 4-byte unsigned value; in the 64-bit DWARF
+format, it is an 8-byte unsigned value (see Section
+\refersec{datarep:32bitand64bitdwarfformats}).
+\end{itemize}
+
+\textit{Because classes
+\CLASSaddrptr, 
+\CLASSlineptr, 
+\CLASSloclistptr, 
+\CLASSmacptr, 
+\CLASSrangelistptr{} and
+\CLASSstroffsetsptr{}
+share a common representation, it is not possible for an
+attribute to allow more than one of these classes}
+
+
+\begin{itemize}
+\item \livelinki{chap:classreference}{reference}{reference class} \\
+\livetarg{datarep:classreference}{}
+There are four types of reference.
+
+The 
+\addtoindexx{reference class}
+first type of reference can identify any debugging
+information entry within the containing unit. 
+This type of
+reference is an 
+\addtoindexx{section offset!in class reference value}
+offset from the first byte of the compilation
+header for the compilation unit containing the reference. There
+are five forms for this type of reference. There are fixed
+length forms for one, two, four and eight byte offsets
+(respectively,
+\DWFORMrefnMARK 
+\DWFORMrefoneTARG, 
+\DWFORMreftwoTARG, 
+\DWFORMreffourTARG,
+and \DWFORMrefeightTARG). 
+There is also an unsigned variable
+length offset encoded form that uses 
+unsigned LEB128\addtoindexx{LEB128!unsigned} numbers
+(\DWFORMrefudataTARG). 
+Because this type of reference is within
+the containing compilation unit no relocation of the value
+is required.
+
+The second type of reference can identify any debugging
+information entry within a 
+\dotdebuginfo{} section; in particular,
+it may refer to an entry in a different compilation unit
+from the unit containing the reference, and may refer to an
+entry in a different shared object.  This type of reference
+(\DWFORMrefaddrTARG) 
+is an offset from the beginning of the
+\dotdebuginfo{} 
+section of the target executable or shared object, or, for
+references within a \addtoindex{supplementary object file}, 
+an offset from the beginning of the local \dotdebuginfo{} section;
+it is relocatable in a relocatable object file and frequently
+relocated in an executable file or shared object. For
+references from one shared object or static executable file
+to another, the relocation and identification of the target
+object must be performed by the consumer. In the 
+\thirtytwobitdwarfformat, this offset is a 4-byte unsigned value; 
+in the \sixtyfourbitdwarfformat, it is an 8-byte
+unsigned value 
+(see Section \refersec{datarep:32bitand64bitdwarfformats}).
+
+\textit{A debugging information entry that may be referenced by
+another compilation unit using 
+\DWFORMrefaddr{} must have a global symbolic name.}
+
+\textit{For a reference from one executable or shared object to
+another, the reference is resolved by the debugger to identify
+the shared object or executable and the offset into that
+object\textquoteright s \dotdebuginfo{}
+section in the same fashion as the run
+time loader, either when the debug information is first read,
+or when the reference is used.}
+
+The third type of reference can identify any debugging
+information type entry that has been placed in its own
+\addtoindex{type unit}. This type of 
+reference (\DWFORMrefsigeightTARG) is the
+\addtoindexx{type signature}
+64-bit type signature 
+(see Section \refersec{datarep:typesignaturecomputation}) 
+that was computed for the type. 
+
+The fourth type of reference is a reference from within the 
+\dotdebuginfo{} section of the executable or shared object to
+a debugging information entry in the \dotdebuginfo{} section of 
+a \addtoindex{supplementary object file}.
+This type of reference (\DWFORMrefsupTARG) is an offset from the 
+beginning of the \dotdebuginfo{} section in the supplementary 
+object file.
+
+\textit{The use of compilation unit relative references will reduce the
+number of link\dash time relocations and so speed up linking. The
+use of the second, third and fourth type of reference allows for the
+sharing of information, such as types, across compilation
+units, while the fourth type further allows for sharing of information 
+across compilation units from different executables or shared objects.}
+
+\textit{A reference to any kind of compilation unit identifies the
+debugging information entry for that unit, not the preceding
+header.}
+
+\needlines{4}
+\item \livelinki{chap:classstring}{string}{string class} \\
+\livetarg{datarep:classstring}{}
+A string is a sequence of contiguous non\dash null bytes followed by
+one null byte. 
+\addtoindexx{string class}
+A string may be represented: 
+\begin{itemize}
+\setlength{\itemsep}{0em}
+\item immediately in the debugging information entry itself 
+(\DWFORMstringTARG), 
+
+\item as an 
+\addtoindexx{section offset!in class string value}
+offset into a string table contained in
+the \dotdebugstr{} section of the object file (\DWFORMstrpTARG), 
+the \dotdebuglinestr{} section of the object file (\DWFORMlinestrpTARG),
+or as an offset into a string table contained in the
+\dotdebugstr{} section of a \addtoindex{supplementary object file} 
+(\DWFORMstrpsupTARG).  \DWFORMstrpsupNAME{} offsets from the \dotdebuginfo{}  
+section of a \addtoindex{supplementary object file}
+refer to the local \dotdebugstr{} section of that same file.
+In the \thirtytwobitdwarfformat, the representation of a 
+\DWFORMstrpNAME{}, \DWFORMstrpNAME{} or \DWFORMstrpsupNAME{}
+value is a 4-byte unsigned offset; in the \sixtyfourbitdwarfformat,
+it is an 8-byte unsigned offset 
+(see Section \refersec{datarep:32bitand64bitdwarfformats}).
+
+\needlines{4}
+\item as an indirect offset into the string table using an 
+index into a table of offsets contained in the 
+\dotdebugstroffsets{} section of the object file (\DWFORMstrxTARG).
+The representation of a \DWFORMstrxNAME{} value is an unsigned 
+\addtoindex{LEB128} value, which is interpreted as a zero-based 
+index into an array of offsets in the \dotdebugstroffsets{} section. 
+The offset entries in the \dotdebugstroffsets{} section have the 
+same representation as \DWFORMstrp{} values.
+\end{itemize}
+Any combination of these three forms may be used within a single compilation.
+
+If the \DWATuseUTFeight{}
+\addtoindexx{use UTF8 attribute}\addtoindexx{UTF-8} attribute is specified for the
+compilation, partial, skeleton or type unit entry, string values are encoded using the
+UTF\dash 8 (\addtoindex{Unicode} Transformation Format\dash 8) from the Universal
+Character Set standard (ISO/IEC 10646\dash 1:1993).
+\addtoindexx{ISO 10646 character set standard}
+Otherwise, the string representation is unspecified.
+
+\textit{The \addtoindex{Unicode} Standard Version 3 is fully compatible with
+ISO/IEC 10646\dash 1:1993. 
+\addtoindexx{ISO 10646 character set standard}
+It contains all the same characters
+and encoding points as ISO/IEC 10646, as well as additional
+information about the characters and their use.}
+
+\textit{Earlier versions of DWARF did not specify the representation
+of strings; for compatibility, this version also does
+not. However, the UTF\dash 8 representation is strongly recommended.}
+
+\needlines{4}
+\item \livelinki{chap:classstroffsetsptr}{stroffsetsptr}{stroffsetsptr class} \\
+\livetarg{datarep:classstroffsetsptr}{}
+This is an offset into the \dotdebugstroffsets{} section 
+(\DWFORMsecoffset). It consists of an offset from the beginning of the 
+\dotdebugstroffsets{} section to the
+beginning of the string offsets information for the
+referencing entity. It is relocatable in
+a relocatable object file, and relocated in an executable or
+shared object. In the \thirtytwobitdwarfformat, this offset
+is a 4-byte unsigned value; in the 64-bit DWARF
+format, it is an 8-byte unsigned value (see Section
+\refersec{datarep:32bitand64bitdwarfformats}).
+
+\textit{This class is new in \DWARFVersionV.}
+
+\end{itemize}
+
+In no case does an attribute use one of the classes 
+\CLASSaddrptr,
+\CLASSlineptr,
+\CLASSloclistptr, 
+\CLASSmacptr, 
+\CLASSrangelistptr{} or 
+\CLASSstroffsetsptr{}
+to point into either the
+\dotdebuginfo{} or \dotdebugstr{} section.
+
+The form encodings are listed in 
+Table \referfol{tab:attributeformencodings}.
 
 \needlines{8}
 \begin{centering}
@@ -2013,7 +2037,7 @@ Unsigned LEB128\addtoindexx{LEB128!unsigned} (\addtoindex{ULEB128})
 numbers are encoded as follows:
 \addtoindexx{LEB128!unsigned, encoding as}
 start at the low order end of an unsigned integer and chop
-it into 7\dash bit chunks. Place each chunk into the low order 7
+it into 7-bit chunks. Place each chunk into the low order 7
 bits of a byte. Typically, several of the high order bytes
 will be zero; discard them. Emit the remaining bytes in a
 stream, starting with the low order byte; set the high order
@@ -2036,7 +2060,7 @@ The encoding for signed, two\textquoteright s complement LEB128
 numbers is similar, except that the criterion for discarding
 high order bytes is not whether they are zero, but whether
 they consist entirely of sign extension bits. Consider the
-32\dash bit integer -2. The three high level bytes of the number
+32-bit integer -2. The three high level bytes of the number
 are sign extension, thus LEB128 would represent it as a single
 byte containing the low order 7 bits, with the high order
 bit cleared to indicate the end of the byte stream. Note
@@ -2116,7 +2140,7 @@ A
 \addtoindexx{DWARF expression!operator encoding}
 DWARF expression is stored in a \nolink{block} of contiguous
 bytes. The bytes form a sequence of operations. Each operation
-is a 1\dash byte code that identifies that operation, followed by
+is a 1-byte code that identifies that operation, followed by
 zero or more bytes of additional data. The encodings for the
 operations are described in 
 Table \refersec{tab:dwarfoperationencodings}. 
@@ -2141,20 +2165,20 @@ Table \refersec{tab:dwarfoperationencodings}.
 
 \DWOPderef&0x06&0 & \\
 
-\DWOPconstoneu&0x08&1&1\dash byte constant  \\
-\DWOPconstones&0x09&1&1\dash byte constant   \\
-\DWOPconsttwou&0x0a&1&2\dash byte constant   \\
-\DWOPconsttwos&0x0b&1&2\dash byte constant   \\
-\DWOPconstfouru&0x0c&1&4\dash byte constant    \\
-\DWOPconstfours&0x0d&1&4\dash byte constant   \\
-\DWOPconsteightu&0x0e&1&8\dash byte constant   \\
-\DWOPconsteights&0x0f&1&8\dash byte constant   \\
+\DWOPconstoneu&0x08&1&1-byte constant  \\
+\DWOPconstones&0x09&1&1-byte constant   \\
+\DWOPconsttwou&0x0a&1&2-byte constant   \\
+\DWOPconsttwos&0x0b&1&2-byte constant   \\
+\DWOPconstfouru&0x0c&1&4-byte constant    \\
+\DWOPconstfours&0x0d&1&4-byte constant   \\
+\DWOPconsteightu&0x0e&1&8-byte constant   \\
+\DWOPconsteights&0x0f&1&8-byte constant   \\
 \DWOPconstu&0x10&1&ULEB128 constant   \\
 \DWOPconsts&0x11&1&SLEB128 constant   \\
 \DWOPdup&0x12&0 &   \\
 \DWOPdrop&0x13&0  &   \\
 \DWOPover&0x14&0 &   \\
-\DWOPpick&0x15&1&1\dash byte stack index   \\
+\DWOPpick&0x15&1&1-byte stack index   \\
 \DWOPswap&0x16&0 &   \\
 \DWOProt&0x17&0 &   \\
 \DWOPxderef&0x18&0 &   \\
@@ -2174,14 +2198,14 @@ Table \refersec{tab:dwarfoperationencodings}.
 \DWOPshra&0x26&0 & \\
 \DWOPxor&0x27&0 & \\
 
-\DWOPbra&0x28&1 & signed 2\dash byte constant \\
+\DWOPbra&0x28&1 & signed 2-byte constant \\
 \DWOPeq&0x29&0 & \\
 \DWOPge&0x2a&0 & \\
 \DWOPgt&0x2b&0 & \\
 \DWOPle&0x2c&0 & \\
 \DWOPlt&0x2d&0  & \\
 \DWOPne&0x2e&0 & \\
-\DWOPskip&0x2f&1&signed 2\dash byte constant \\ \hline
+\DWOPskip&0x2f&1&signed 2-byte constant \\ \hline
 
 \DWOPlitzero & 0x30 & 0 & \\
 \DWOPlitone  & 0x31 & 0& literals 0 .. 31 = \\
@@ -2208,9 +2232,9 @@ Table \refersec{tab:dwarfoperationencodings}.
 \DWOPnop{} & 0x96 &0& \\
 
 \DWOPpushobjectaddress&0x97&0 &  \\
-\DWOPcalltwo&0x98&1& 2\dash byte offset of DIE \\
-\DWOPcallfour&0x99&1& 4\dash byte offset of DIE \\
-\DWOPcallref&0x9a&1& 4\dash\  or 8\dash byte offset of DIE \\
+\DWOPcalltwo&0x98&1& 2-byte offset of DIE \\
+\DWOPcallfour&0x99&1& 4-byte offset of DIE \\
+\DWOPcallref&0x9a&1& 4\dash\  or 8-byte offset of DIE \\
 \DWOPformtlsaddress&0x9b &0& \\
 \DWOPcallframecfa{} &0x9c &0& \\
 \DWOPbitpiece&0x9d &2&ULEB128 size, \\*
@@ -2259,7 +2283,7 @@ end-of-list entry.
 \needlines{6}
 \subsubsection{Location List Entries in Non-Split Objects}
 A \addtoindex{location list} entry consists of two address offsets followed
-by an unsigned 2\dash byte length, followed by a block of contiguous bytes
+by an unsigned 2-byte length, followed by a block of contiguous bytes
 that contains a DWARF location description. The length
 specifies the number of bytes in that block. The two offsets
 are the same size as an address on the target machine.
@@ -2283,6 +2307,7 @@ Each entry begins with an unsigned 1-byte code that indicates the kind of entry
 that follows. The encodings for these constants are given in
 Table \refersec{tab:locationlistentryencodingvalues}.
 
+\needlines{10}
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \begin{longtable}{l|c}
@@ -2406,6 +2431,7 @@ Table \refersec{tab:endianityencodings}.
 \end{longtable}
 \end{centering}
 
+\needlines{10}
 \section{Accessibility Codes}
 \label{datarep:accessibilitycodes}
 The encodings of the constants used in the 
@@ -2486,11 +2512,10 @@ Table \refersec{tab:virtualityencodings}.
 \DWVIRTUALITYvirtual&0x01 \\
 \DWVIRTUALITYpurevirtual&0x02 \\
 
-
-
 \end{longtable}
 \end{centering}
 
+\needlines{4}
 The value 
 \DWVIRTUALITYnone{} is equivalent to the absence of the 
 \DWATvirtuality{}
@@ -2583,7 +2608,7 @@ The value of the common
 \addtoindex{address class} encoding 
 \DWADDRnone{} is 0.
 
-\needlines{7}
+\needlines{16}
 \section{Identifier Case}
 \label{datarep:identifiercase}
 
@@ -2591,6 +2616,7 @@ The encodings of the constants used in the
 \DWATidentifiercase{} attribute are given in 
 Table \refersec{tab:identifiercaseencodings}.
 
+\needlines{8}
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \begin{longtable}{l|c}
@@ -2710,7 +2736,7 @@ The descriptors used in
 \addtoindexx{discriminant list attribute}
 the 
 \DWATdiscrlist{} attribute are 
-encoded as 1\dash byte constants. The
+encoded as 1-byte constants. The
 defined values are given in 
 Table \refersec{tab:discriminantdescriptorencodings}.
 
@@ -2747,7 +2773,7 @@ contains the size in bytes of this contribution to the \dotdebugnames{}
 section, not including the length field itself
 (see Section \refersec{datarep:initiallengthvalues}).
 
-\item \texttt{version} (\addtoindex{uhalf}) \\
+\item \texttt{version} (\HFTuhalf) \\
 A 2-byte version number\addtoindexx{version number!name index table} 
 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}). 
 This number is specific to the name index table and is
@@ -2755,32 +2781,32 @@ independent of the DWARF version number.
 
 The value in this field is \versiondotdebugnames.
 
-\item padding (\addtoindex{uhalf}) \\
+\item padding (\HFTuhalf) \\
 
-\item \texttt{comp\_unit\_count} (4-byte unsigned integer) \\
+\item \texttt{comp\_unit\_count} (\HFTuword) \\
 The number of CUs in the CU list.
 
-\item \texttt{local\_type\_unit\_count} (4-byte unsigned integer) \\
+\item \texttt{local\_type\_unit\_count} (\HFTuword) \\
 The number of TUs in the first TU list.
 
-\item \texttt{foreign\_type\_unit\_count} (4-byte unsigned integer) \\
+\item \texttt{foreign\_type\_unit\_count} (\HFTuword) \\
 The number of TUs in the second TU list.
 
-\item \texttt{bucket\_count} (4-byte unsigned integer) \\
+\item \texttt{bucket\_count} (\HFTuword) \\
 The number of hash buckets in the hash lookup table. 
 If there is no hash lookup table, this field contains 0.
 
-\item \texttt{name\_count} (4-byte unsigned integer) \\
+\item \texttt{name\_count} (\HFTuword) \\
 The number of unique names in the index.
 
-\item \texttt{abbrev\_table\_size} (4-byte unsigned integer) \\
+\item \texttt{abbrev\_table\_size} (\HFTuword) \\
 The size in bytes of the abbreviations table.
 
-\item \texttt{augmentation\_string\_size} (4-byte unsigned integer) \\
+\item \texttt{augmentation\_string\_size} (\HFTuword) \\
 The size in bytes of the augmentation string. This value should be
 rounded up to a multiple of 4.
 
-\item \texttt{augmentation\_string} (sequence of characters) \\
+\item \texttt{augmentation\_string} (\HFTaugstring) \\
 A vendor-specific augmentation string, which provides additional 
 information about the contents of this index. If provided, the string
 should begin with a 4-character vendor ID. The remainder of the
@@ -2830,15 +2856,15 @@ are given in Table \referfol{datarep:defaultedattributeencodings}.
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \begin{longtable}{l|c}
-  \caption{Defaulted attribute encodings} \label{datarep:defaultedattributeencodings}\\
-  \hline \bfseries Defaulted name&\bfseries Value \\ \hline
+  \caption{Defaulted attribute encodings} \label{datarep:defaultedattributeencodings} \\
+  \hline \bfseries Defaulted name &\bfseries Value \\ \hline
 \endfirsthead
-  \bfseries Defaulted name&\bfseries Value \\ \hline
+  \bfseries Defaulted name &\bfseries Value \\ \hline
 \endhead
   \hline \emph{Continued on next page}
 \endfoot
   \hline
-  \ddag \ \textit{New in \DWARFVersionV}
+  \ddag~\textit{New in \DWARFVersionV}
 \endlastfoot
 \DWDEFAULTEDno~\ddag   & 0x00 \\
 \DWDEFAULTEDinclass~\ddag       & 0x01 \\
@@ -2869,8 +2895,8 @@ in the \sixtyfourbitdwarfformat, this consists of the 4-byte value
 the actual length 
 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
 
-\item version (\addtoindex{uhalf}) \\
-A 2\dash byte version identifier representing the version of the
+\item version (\HFTuhalf) \\
+A 2-byte version identifier representing the version of the
 DWARF information for the address range table
 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
 
@@ -2879,15 +2905,15 @@ This value in this field \addtoindexx{version number!address range table} is 2.
 \item debug\_info\_offset (\livelink{datarep:sectionoffsetlength}{section offset}) \\
 A 
 \addtoindexx{section offset!in .debug\_aranges header}
-4\dash byte or 8\dash byte offset into the 
+4-byte or 8-byte offset into the 
 \dotdebuginfo{} section of
 the compilation unit header. In the \thirtytwobitdwarfformat,
-this is a 4\dash byte unsigned offset; in the \sixtyfourbitdwarfformat,
-this is an 8\dash byte unsigned offset 
+this is a 4-byte unsigned offset; in the \sixtyfourbitdwarfformat,
+this is an 8-byte unsigned offset 
 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
 
-\item \texttt{address\_size} (\addtoindex{ubyte}) \\
-A 1\dash byte unsigned integer containing the size in bytes of an
+\item \texttt{address\_size} (\HFTubyte) \\
+A 1-byte unsigned integer containing the size in bytes of an
 \addttindexx{address\_size}
 address 
 \addtoindexx{size of an address}
@@ -2895,10 +2921,10 @@ address
 \addtoindexx{address space!segmented}
 addressing) on the target system.
 
-\item \texttt{segment\_size} (\addtoindex{ubyte}) \\
+\item \texttt{segment\_size} (\HFTubyte) \\
 A 
 \addttindexx{segment\_size}
-1\dash byte unsigned integer containing the size in bytes of a
+1-byte unsigned integer containing the size in bytes of a
 segment selector on the target system.
 
 \end{enumerate}
@@ -2933,13 +2959,11 @@ used by the line number information program are encoded
 as a single byte containing the value 0 
 for \doublequote{false,} and a non-zero value for \doublequote{true.}
 
-\clearpage
 \needlines{10}
 The encodings for the standard opcodes are given in 
 \addtoindexx{line number opcodes!standard opcode encoding}
 Table \refersec{tab:linenumberstandardopcodeencodings}.
 
-% Odd that the 'Name' field capitalized here, it is not caps elsewhere.
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \begin{longtable}{l|c}
@@ -2965,11 +2989,11 @@ Table \refersec{tab:linenumberstandardopcodeencodings}.
 \DWLNSsetprologueend&0x0a \\*
 \DWLNSsetepiloguebegin&0x0b \\*
 \DWLNSsetisa&0x0c \\*
-
 \end{longtable}
 \end{centering}
 
-\needspace{6cm}
+\clearpage
+\needlines{12}
 The encodings for the extended opcodes are given in 
 \addtoindexx{line number opcodes!extended opcode encoding}
 Table \refersec{tab:linenumberextendedopcodeencodings}.
@@ -2999,8 +3023,7 @@ Table \refersec{tab:linenumberextendedopcodeencodings}.
 \end{longtable}
 \end{centering}
 
-\clearpage
-\needspace{6cm}
+\needlines{6}
 The encodings for the line number header entry formats are given in 
 \addtoindexx{line number opcodes!file entry format encoding}
 Table \refersec{tab:linenumberheaderentryformatencodings}.
@@ -3027,6 +3050,7 @@ Table \refersec{tab:linenumberheaderentryformatencodings}.
 \end{longtable}
 \end{centering}
 
+\needlines{6}
 \section{Macro Information}
 \label{datarep:macroinformation}
 The \addtoindexi{version number}{version number!macro information}
@@ -3115,9 +3139,9 @@ Table \refersec{tab:callframeinstructionencodings}.
 \DWCFArestore&0x3&register & & \\
 \DWCFAnop&0&0 & & \\
 \DWCFAsetloc&0&0x01&address & \\
-\DWCFAadvancelocone&0&0x02&1\dash byte delta & \\
-\DWCFAadvanceloctwo&0&0x03&2\dash byte delta & \\
-\DWCFAadvancelocfour&0&0x04&4\dash byte delta & \\
+\DWCFAadvancelocone&0&0x02&1-byte delta & \\
+\DWCFAadvanceloctwo&0&0x03&2-byte delta & \\
+\DWCFAadvancelocfour&0&0x04&4-byte delta & \\
 \DWCFAoffsetextended&0&0x05&ULEB128 register&ULEB128 offset \\
 \DWCFArestoreextended&0&0x06&ULEB128 register & \\
 \DWCFAundefined&0&0x07&ULEB128 register & \\
@@ -3189,12 +3213,12 @@ that gives the actual length (see
 Section \refersec{datarep:32bitand64bitdwarfformats}).
 
 %\needlines{4}
-\item  \texttt{version} (\addtoindex{uhalf}) \\
+\item  \texttt{version} (\HFTuhalf) \\
 A 2-byte version identifier containing the value
 \versiondotdebugstroffsets{} 
 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
 
-\item \texttt{padding} (\addtoindex{uhalf}) \\
+\item \texttt{padding} (\HFTuhalf) \\
 \end{enumerate}
 
 This header is followed by a series of string table offsets
@@ -3224,20 +3248,20 @@ that gives the actual length (see
 Section \refersec{datarep:32bitand64bitdwarfformats}).
 
 \needlines{4}
-\item  \texttt{version} (\addtoindex{uhalf}) \\
+\item  \texttt{version} (\HFTuhalf) \\
 A 2-byte version identifier containing the value
 \versiondotdebugaddr{} 
 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
 
 \needlines{4}
-\item  \texttt{address\_size} (\addtoindex{ubyte}) \\
+\item  \texttt{address\_size} (\HFTubyte) \\
 A 1-byte unsigned integer containing the size in
 bytes of an address (or the offset portion of an
 address for segmented addressing) on the target
 system.
 
 \needlines{4}
-\item  \texttt{segment\_size} (\addtoindex{ubyte}) \\
+\item  \texttt{segment\_size} (\HFTubyte) \\
 A 1-byte unsigned integer containing the size in
 bytes of a segment selector on the target system.
 \end{enumerate}
@@ -3252,6 +3276,7 @@ The \DWATaddrbase{} attribute points to the first entry
 following the header. The entries are indexed sequentially
 from this base entry, starting from 0.
 
+\needlines{10}
 \section{Range List Table}
 \label{app:rangelisttable}
 Each set of entries in the range list table contained in the
@@ -3270,20 +3295,20 @@ that gives the actual length (see
 Section \refersec{datarep:32bitand64bitdwarfformats}).
 
 \needlines{4}
-\item  \texttt{version} (\addtoindex{uhalf}) \\
+\item  \texttt{version} (\HFTuhalf) \\
 A 2-byte version identifier containing the value
 \versiondotdebugranges{} 
 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
 
 \needlines{4}
-\item  \texttt{address\_size} (\addtoindex{ubyte}) \\
+\item  \texttt{address\_size} (\HFTubyte) \\
 A 1-byte unsigned integer containing the size in
 bytes of an address (or the offset portion of an
 address for segmented addressing) on the target
 system.
 
 \needlines{4}
-\item  \texttt{segment\_size} (\addtoindex{ubyte}) \\
+\item  \texttt{segment\_size} (\HFTubyte) \\
 A 1-byte unsigned integer containing the size in
 bytes of a segment selector on the target system.
 \end{enumerate}
@@ -3319,20 +3344,20 @@ that gives the actual length (see
 Section \refersec{datarep:32bitand64bitdwarfformats}).
 
 \needlines{4}
-\item  \texttt{version} (\addtoindex{uhalf}) \\
+\item  \texttt{version} (\HFTuhalf) \\
 A 2-byte version identifier containing the value
 \versiondotdebugloc{} 
 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
 
 \needlines{5}
-\item  \texttt{address\_size} (\addtoindex{ubyte}) \\
+\item  \texttt{address\_size} (\HFTubyte) \\
 A 1-byte unsigned integer containing the size in
 bytes of an address (or the offset portion of an
 address for segmented addressing) on the target
 system.
 
 \needlines{4}
-\item  \texttt{segment\_size} (\addtoindex{ubyte}) \\
+\item  \texttt{segment\_size} (\HFTubyte) \\
 A 1-byte unsigned integer containing the size in
 bytes of a segment selector on the target system.
 \end{enumerate}
@@ -3352,71 +3377,58 @@ location list following this header.
 \section{Dependencies and Constraints}
 \label{datarep:dependenciesandconstraints}
 The debugging information in this format is intended to
-exist 
-\addtoindexx{DWARF section names!list of}
-in the
-\dotdebugabbrev{},
-\dotdebugaddr{}, 
-\dotdebugaranges{}, 
-\dotdebugframe{},
-\dotdebuginfo{}, 
-\dotdebugline{}, 
-\dotdebuglinestr{},
-\dotdebugloc{}, 
-\dotdebugmacro{},
-\dotdebugnames{}, 
-\dotdebugranges{}, 
-\dotdebugstr{},
-and
-\dotdebugstroffsets{}
-sections of an object file, or equivalent
-separate file or database. The information is not 
-word\dash aligned. Consequently:
+exist in sections of an object file, or an equivalent
+separate file or database, having names beginning with
+the prefix ".debug\_" (see Appendix 
+\refersec{app:dwarfsectionversionnumbersinformative}
+for a complete list of such names). 
+Except as specifically specified, this information is not 
+aligned on 2-, 4- or 8-byte boundaries. Consequently:
 
 \begin{itemize}
 \item For the \thirtytwobitdwarfformat{} and a target architecture with
-32\dash bit addresses, an assembler or compiler must provide a way
-to produce 2\dash byte and 4\dash byte quantities without alignment
+32-bit addresses, an assembler or compiler must provide a way
+to produce 2-byte and 4-byte quantities without alignment
 restrictions, and the linker must be able to relocate a
-4\dash byte address or 
+4-byte address or 
 \addtoindexx{section offset!alignment of}
 section offset that occurs at an arbitrary
 alignment.
 
 \item For the \thirtytwobitdwarfformat{} and a target architecture with
-64\dash bit addresses, an assembler or compiler must provide a
-way to produce 2\dash byte, 4\dash byte and 8\dash byte quantities without
+64-bit addresses, an assembler or compiler must provide a
+way to produce 2-byte, 4-byte and 8-byte quantities without
 alignment restrictions, and the linker must be able to relocate
-an 8\dash byte address or 4\dash byte 
+an 8-byte address or 4-byte 
 \addtoindexx{section offset!alignment of}
 section offset that occurs at an
 arbitrary alignment.
 
 \item For the \sixtyfourbitdwarfformat{} and a target architecture with
-32\dash bit addresses, an assembler or compiler must provide a
-way to produce 2\dash byte, 4\dash byte and 8\dash byte quantities without
+32-bit addresses, an assembler or compiler must provide a
+way to produce 2-byte, 4-byte and 8-byte quantities without
 alignment restrictions, and the linker must be able to relocate
-a 4\dash byte address or 8\dash byte 
+a 4-byte address or 8-byte 
 \addtoindexx{section offset!alignment of}
 section offset that occurs at an
 arbitrary alignment.
 
 \textit{It is expected that this will be required only for very large
-32\dash bit programs or by those architectures which support
-a mix of 32\dash bit and 64\dash bit code and data within the same
+32-bit programs or by those architectures which support
+a mix of 32-bit and 64-bit code and data within the same
 executable object.}
 
 \item For the \sixtyfourbitdwarfformat{} and a target architecture with
-64\dash bit addresses, an assembler or compiler must provide a
-way to produce 2\dash byte, 4\dash byte and 8\dash byte quantities without
+64-bit addresses, an assembler or compiler must provide a
+way to produce 2-byte, 4-byte and 8-byte quantities without
 alignment restrictions, and the linker must be able to
-relocate an 8\dash byte address or 
+relocate an 8-byte address or 
 \addtoindexx{section offset!alignment of}
 section offset that occurs at
 an arbitrary alignment.
 \end{itemize}
 
-\needlines{8}
+\needlines{10}
 \section{Integer Representation Names}
 \label{datarep:integerrepresentationnames}
 The sizes of the integers used in the lookup by name, lookup
@@ -3438,10 +3450,10 @@ Table \ref{tab:integerrepresentationnames}.
   \hline
 \endlastfoot
 
-\addtoindex{sbyte}&  signed, 1\dash byte integer \\
-\addtoindex{ubyte}&unsigned, 1\dash byte integer \\
-\addtoindex{uhalf}&unsigned, 2\dash byte integer \\
-\addtoindex{uword}&unsigned, 4\dash byte integer \\
+\HFTsbyte&  signed, 1-byte integer \\
+\HFTubyte&unsigned, 1-byte integer \\
+\HFTuhalf&unsigned, 2-byte integer \\
+\HFTuword&unsigned, 4-byte integer \\
 
 \end{longtable}
 \end{centering}