\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.
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
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
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}
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).
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
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
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
\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}
\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}
\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
(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{}
\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.}
\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
\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
\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
\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
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.
\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.
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}
\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
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}
\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}
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
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
\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}.
\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 & \\
\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 = \\
\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, \\*
\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.
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}
\end{longtable}
\end{centering}
+\needlines{10}
\section{Accessibility Codes}
\label{datarep:accessibilitycodes}
The encodings of the constants used in the
\DWVIRTUALITYvirtual&0x01 \\
\DWVIRTUALITYpurevirtual&0x02 \\
-
-
\end{longtable}
\end{centering}
+\needlines{4}
The value
\DWVIRTUALITYnone{} is equivalent to the absence of the
\DWATvirtuality{}
\addtoindex{address class} encoding
\DWADDRnone{} is 0.
-\needlines{7}
+\needlines{16}
\section{Identifier Case}
\label{datarep:identifiercase}
\DWATidentifiercase{} attribute are given in
Table \refersec{tab:identifiercaseencodings}.
+\needlines{8}
\begin{centering}
\setlength{\extrarowheight}{0.1cm}
\begin{longtable}{l|c}
\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}.
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
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
\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 \\
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}).
\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}
\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}
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}
\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}.
\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}.
\end{longtable}
\end{centering}
+\needlines{6}
\section{Macro Information}
\label{datarep:macroinformation}
The \addtoindexi{version number}{version number!macro information}
\DWCFArestore&0x3®ister & & \\
\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 & \\
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
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}
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
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}
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}
\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
\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}
\endfoot
\hline
\endlastfoot
+
\DWATabstractoriginTARG
-&\livelinki{chap:DWATabstractorigininlineinstance}{Inline instances of inline subprograms} {inline instances of inline subprograms} \\
+&\livelinki{chap:DWATabstractorigininlineinstance}
+ {Inline instances of inline subprograms}
+ {inline instances of inline subprograms} \\
% Heren livelink we cannot use \dash or \dash{}.
-&\livelinki{chap:DWATabstractoriginoutoflineinstance}{Out-of-line instances of inline subprograms}{out-of-line instances of inline subprograms} \\
+&\livelinki{chap:DWATabstractoriginoutoflineinstance}
+ {Out-of-line instances of inline subprograms}
+ {out-of-line instances of inline subprograms} \\
\DWATaccessibilityTARG
-&\livelink{chap:DWATaccessibilitycandadadeclarations}{C++ and Ada declarations} \addtoindexx{Ada} \\
-&\livelink{chap:DWATaccessibilitycppbaseclasses}{C++ base classes} \\
-&\livelink{chap:DWATaccessibilitycppinheritedmembers}{C++ inherited members} \\
+&\livelink{chap:DWATaccessibilitycandadadeclarations}
+ {Accessibility of declarations} (\addtoindex{C++}, \addtoindex{Ada}) \\
+&\livelink{chap:DWATaccessibilitycppbaseclasses}
+ {Accessibility of base classes} (\addtoindex{C++}) \\
+&\livelink{chap:DWATaccessibilitycppinheritedmembers}
+ {Accessibility of inherited members} (\addtoindex{C++}) \\
\DWATaddressclassTARG
-&\livelinki{chap:DWATadressclasspointerorreferencetypes}{Pointer or reference types}{pointer or reference types} \\
+&\livelinki{chap:DWATadressclasspointerorreferencetypes}
+ {Pointer or reference types}
+ {pointer or reference types} \\
&\livelinki{chap:DWATaddressclasssubroutineorsubroutinetype}
- {Subroutine or subroutine type}
- {subroutine or subroutine type} \\
+ {Subroutine or subroutine type}
+ {subroutine or subroutine type} \\
\DWATaddrbaseTARG
&\livelinki{chap:DWATaddrbaseforaddresstable}{Base offset for address table}{address table} \\
\DWATalignmentTARG
&\livelinki{chap:DWATalignmentnondefault}
- {Non-default alignment of type, subprogram or variable}
- {non-default alignment} \addtoindexx{alignment!non-default} \\
+ {Non-default alignment of type, subprogram or variable}
+ {non-default alignment} \addtoindexx{alignment!non-default} \\
\DWATallocatedTARG
-&\livelinki{chap:DWATallocatedallocationstatusoftypes}{Allocation status of types}{allocation status of types} \\
+&\livelinki{chap:DWATallocatedallocationstatusoftypes}
+ {Allocation status of types}
+ {allocation status of types} \\
\DWATartificialTARG
&\livelinki{chap:DWATartificialobjectsortypesthat}
- {Objects or types that are not actually declared in the source}
- {objects or types that are not actually declared in the source} \\
+ {Objects or types that are not actually declared in the source}
+ {objects or types that are not actually declared in the source} \\
\DWATassociatedTARG{}
-&\livelinki{chap:DWATassociatedassociationstatusoftypes}{Association status of types}{association status of types} \\
+&\livelinki{chap:DWATassociatedassociationstatusoftypes}
+ {Association status of types}
+ {association status of types} \\
\DWATbasetypesTARG{}
&\livelinki{chap:DWATbasetypesprimitivedatatypesofcompilationunit}
- {Primitive data types of compilation unit}
- {primitive data types of compilation unit} \\
+ {Primitive data types of compilation unit}
+ {primitive data types of compilation unit} \\
\DWATbinaryscaleTARG{}
&\livelinki{chap:DWATbinaryscalebinaryscalefactorforfixedpointtype}
- {Binary scale factor for fixed-point type}
- {binary scale factor for fixed-point type} \\
+ {Binary scale factor for fixed-point type}
+ {binary scale factor for fixed-point type} \\
%\DWATbitoffsetTARG{}
%&\livelinki{chap:DWATbitoffsetbasetypebitlocation}{Base type bit location}{base type bit location} \\
%&\livelinki{chap:DWATbitoffsetdatamemberbitlocation}{Data member bit location}{data member bit location} \\
{enumeration stride (dimension of array type)} \\
\DWATbytesizeTARG{}
&\livelinki{chap:DWATbytesizedataobjectordatatypesize}
- {Size of a data object or data type in bytes}{data object or data type size} \\
+ {Size of a data object or data type in bytes}
+ {data object or data type size} \\
\DWATbytestrideTARG{}
&\livelinki{chap:DWATbytestridearrayelementstrideofarraytype}
{Array element stride (of array type)}
&\livelinki{chap:DWATconstvalueenumerationliteralvalue}{Enumeration literal value}{enumeration literal value} \\
&\livelinki{chap:DWATconstvaluetemplatevalueparameter}{Template value parameter}{template value parameter} \\
\DWATconstexprTARG
-&\livelinki{chap:DWATconstexprcompiletimeconstantobject}{Compile-time constant object}{compile-time constant object} \\
-&\livelinki{chap:DWATconstexprcompiletimeconstantfunction}{Compile-time constant function}{compile-time constant function} \\
+&\livelinki{chap:DWATconstexprcompiletimeconstantobject}
+ {Compile-time constant object}
+ {compile-time constant object} \\
+&\livelinki{chap:DWATconstexprcompiletimeconstantfunction}
+ {Compile-time constant function}
+ {compile-time constant function} \\
\DWATcontainingtypeTARG
-&\livelinki{chap:DWATcontainingtypecontainingtypeofpointertomembertype}{Containing type of pointer to member type}{containing type of pointer to member type} \\
+&\livelinki{chap:DWATcontainingtypecontainingtypeofpointertomembertype}
+ {Containing type of pointer to member type}
+ {containing type of pointer to member type} \\
\DWATcountTARG
&\livelinki{chap:DWATcountelementsofsubrangetype}{Elements of subrange type}{elements of breg subrange type} \\
\DWATdatabitoffsetTARG
\DWATdecimalsignTARG
&\livelinki{chap:DWATdecimalsigndecimalsignrepresentation}{Decimal sign representation}{decimal sign representation} \\
\DWATdeclcolumnTARG
-&\livelinki{chap:DWATdeclcolumncolumnpositionofsourcedeclaration}{Column position of source declaration}{column position of source declaration} \\
+&\livelinki{chap:DWATdeclcolumncolumnpositionofsourcedeclaration}
+ {Column position of source declaration}
+ {column position of source declaration} \\
\DWATdeclfileTARG
-&\livelinki{chap:DWATdeclfilefilecontainingsourcedeclaration}{File containing source declaration}{file containing source declaration} \\
+&\livelinki{chap:DWATdeclfilefilecontainingsourcedeclaration}
+ {File containing source declaration}
+ {file containing source declaration} \\
\DWATdecllineTARG
-&\livelinki{chap:DWATdecllinelinenumberofsourcedeclaration}{Line number of source declaration}{line number of source declaration} \\
+&\livelinki{chap:DWATdecllinelinenumberofsourcedeclaration}
+ {Line number of source declaration}
+ {line number of source declaration} \\
\DWATdeclarationTARG
-&\livelinki{chap:DWATdeclarationincompletenondefiningorseparateentitydeclaration}{Incomplete, non-defining, or separate entity declaration}{incomplete, non-defining, or separate entity declaration} \\
+&\livelinki{chap:DWATdeclarationincompletenondefiningorseparateentitydeclaration}
+ {Incomplete, non-defining, or separate entity declaration}
+ {incomplete, non-defining, or separate entity declaration} \\
\DWATdefaultedTARG
&\livelinki{chap:DWATdefaulteddef}{Whether a member function has been declared as default}{defaulted attribute} \\
\DWATdefaultvalueTARG
\DWATdeletedTARG
&\livelinki{chap:DWATdeleteddef}{Whether a member has been declared as deleted}{Deletion of member function} \\
\DWATdescriptionTARG{}
-&\livelinki{chap:DWATdescriptionartificialnameordescription}{Artificial name or description}{artificial name or description} \\
+&\livelinki{chap:DWATdescriptionartificialnameordescription}
+ {Artificial name or description}
+ {artificial name or description} \\
\DWATdigitcountTARG
-&\livelinki{chap:DWATdigitcountdigitcountforpackeddecimalornumericstringtype}{Digit count for packed decimal or numeric string type}{digit count for packed decimal or numeric string type} \\
+&\livelinki{chap:DWATdigitcountdigitcountforpackeddecimalornumericstringtype}
+ {Digit count for packed decimal or numeric string type}
+ {digit count for packed decimal or numeric string type} \\
\DWATdiscrTARG
&\livelinki{chap:DWATdiscrdiscriminantofvariantpart}{Discriminant of variant part}{discriminant of variant part} \\
\DWATdiscrlistTARG
\DWATdwonameTARG
&\livelinki{chap:DWATdwonameforunit}{Name of split DWARF object file}{split DWARF object file!object file name} \\
\DWATelementalTARG
-&\livelinki{chap:DWATelementalelementalpropertyofasubroutine}{Elemental property of a subroutine}{elemental property of a subroutine} \\
+&\livelinki{chap:DWATelementalelementalpropertyofasubroutine}
+ {Elemental property of a subroutine}
+ {elemental property of a subroutine} \\
\DWATencodingTARG
&\livelinki{chap:DWATencodingencodingofbasetype}{Encoding of base type}{encoding of base type} \\
\DWATendianityTARG
\DWATentrypcTARG
&\livelinki{chap:entryaddressofscope}{Entry address of a scope (compilation unit, \mbox{subprogram,} and so on)}{} \\
\DWATenumclassTARG
-&\livelinki{chap:DWATenumclasstypesafeenumerationdefinition}{Type safe enumeration definition}{type safe enumeration definition}\\
+&\livelinki{chap:DWATenumclasstypesafeenumerationdefinition}
+ {Type safe enumeration definition}
+ {type safe enumeration definition}\\
\DWATexplicitTARG
-&\livelinki{chap:DWATexplicitexplicitpropertyofmemberfunction}{Explicit property of member function}{explicit property of member function}\\
+&\livelinki{chap:DWATexplicitexplicitpropertyofmemberfunction}
+ {Explicit property of member function}
+ {explicit property of member function}\\
\DWATexportsymbolsTARG
-&\livelinki{chap:DWATexportsymbolsofnamespace}{Export (inline) symbols of namespace}
- {export symbols of a namespace} \\
-&\livelinki{chap:DWATexportsymbolsofstructunionclass}{Export symbols of a structure, union or class}
- {export symbols of a structure, union or class} \\
+&\livelinki{chap:DWATexportsymbolsofnamespace}
+ {Export (inline) symbols of namespace}
+ {export symbols of a namespace} \\
+&\livelinki{chap:DWATexportsymbolsofstructunionclass}
+ {Export symbols of a structure, union or class}
+ {export symbols of a structure, union or class} \\
\DWATextensionTARG
-&\livelinki{chap:DWATextensionpreviousnamespaceextensionororiginalnamespace}{Previous namespace extension or original namespace}{previous namespace extension or original namespace}\\
+&\livelinki{chap:DWATextensionpreviousnamespaceextensionororiginalnamespace}
+ {Previous namespace extension or original namespace}
+ {previous namespace extension or original namespace}\\
\DWATexternalTARG
&\livelinki{chap:DWATexternalexternalsubroutine}{External subroutine}{external subroutine} \\
&\livelinki{chap:DWATexternalexternalvariable}{External variable}{external variable} \\
\DWATfriendTARG
&\livelinki{chap:DWATfriendfriendrelationship}{Friend relationship}{friend relationship} \\
\DWAThighpcTARG
-&\livelinki{chap:DWAThighpccontiguousrangeofcodeaddresses}{Contiguous range of code addresses}{contiguous range of code addresses} \\
+&\livelinki{chap:DWAThighpccontiguousrangeofcodeaddresses}
+ {Contiguous range of code addresses}
+ {contiguous range of code addresses} \\
\DWATidentifiercaseTARG
&\livelinki{chap:DWATidentifiercaseidentifiercaserule}{Identifier case rule}{identifier case rule} \\
\DWATimportTARG
\DWATlanguageTARG
&\livelinki{chap:DWATlanguageprogramminglanguage}{Programming language}{programming language} \\
\DWATlinkagenameTARG
-&\livelinki{chap:DWATlinkagenameobjectfilelinkagenameofanentity}{Object file linkage name of an entity}{object file linkage name of an entity}\\
+&\livelinki{chap:DWATlinkagenameobjectfilelinkagenameofanentity}
+ {Object file linkage name of an entity}
+ {object file linkage name of an entity}\\
\DWATlocationTARG
&\livelinki{chap:DWATlocationdataobjectlocation}{Data object location}{data object location}\\
\DWATlowpcTARG
-&\livelinki{chap:DWATlowpccodeaddressorrangeofaddresses}{Code address or range of addresses}{code address or range of addresses}\\
+&\livelinki{chap:DWATlowpccodeaddressorrangeofaddresses}
+ {Code address or range of addresses}
+ {code address or range of addresses}\\
\DWATlowerboundTARG
&\livelinki{chap:DWATlowerboundlowerboundofsubrange}{Lower bound of subrange}{lower bound of subrange} \\
\DWATmacroinfoTARG
\addtoindex{C++} and similar languages)} \\
\DWATmainsubprogramTARG
&\livelinki{chap:DWATmainsubprogrammainorstartingsubprogram}{Main or starting subprogram}{main or starting subprogram} \\
-&\livelinki{chap:DWATmainsubprogramunitcontainingmainorstartingsubprogram}{Unit containing main or starting subprogram}{unit containing main or starting subprogram}\\
+&\livelinki{chap:DWATmainsubprogramunitcontainingmainorstartingsubprogram}
+ {Unit containing main or starting subprogram}
+ {unit containing main or starting subprogram}\\
\DWATmutableTARG
-&\livelinki{chap:DWATmutablemutablepropertyofmemberdata}{Mutable property of member data}{mutable property of member data} \\
+&\livelinki{chap:DWATmutablemutablepropertyofmemberdata}
+ {Mutable property of member data}
+ {mutable property of member data} \\
\DWATnameTARG
&\livelinki{chap:DWATnamenameofdeclaration}{Name of declaration}{name of declaration}\\
&\livelinki{chap:DWATnamepathnameofcompilationsource}{Path name of compilation source}{path name of compilation source} \\
\DWATnoreturnTARG
&\livelinki{chap:DWATnoreturnofsubprogram}{\doublequote{no return} property of a subprogram}{noreturn attribute} \\
\DWATobjectpointerTARG
-&\livelinki{chap:DWATobjectpointerobjectthisselfpointerofmemberfunction}{Object (\texttt{this}, \texttt{self}) pointer of member function}{object (\texttt{this}, \texttt{self}) pointer of member function}\\
+&\livelinki{chap:DWATobjectpointerobjectthisselfpointerofmemberfunction}
+ {Object (\texttt{this}, \texttt{self}) pointer of member function}
+ {object (\texttt{this}, \texttt{self}) pointer of member function}\\
\DWATorderingTARG
&\livelinki{chap:DWATorderingarrayrowcolumnordering}{Array row/column ordering} {array row/column ordering}\\
\DWATpicturestringTARG
-&\livelinki{chap:DWATpicturestringpicturestringfornumericstringtype}{Picture string for numeric string type}{picture string for numeric string type} \\
+&\livelinki{chap:DWATpicturestringpicturestringfornumericstringtype}
+ {Picture string for numeric string type}
+ {picture string for numeric string type} \\
\DWATpriorityTARG
&\livelinki{chap:DWATprioritymodulepriority}{Module priority}{module priority}\\
\DWATproducerTARG
\DWATpureTARG
&\livelinki{chap:DWATpurepurepropertyofasubroutine}{Pure property of a subroutine}{pure property of a subroutine} \\
\DWATrangesTARG
-&\livelinki{chap:DWATrangesnoncontiguousrangeofcodeaddresses}{Non-contiguous range of code addresses}{non-contiguous range of code addresses} \\
+&\livelinki{chap:DWATrangesnoncontiguousrangeofcodeaddresses}
+ {Non-contiguous range of code addresses}
+ {non-contiguous range of code addresses} \\
\DWATrangesbaseTARG
&\livelinki{chap:DWATrangesbaseforrangelists}{Base offset for range lists}{ranges lists} \\
\DWATrankTARG
&\livelinki{chap:DWATrankofdynamicarray}{Dynamic number of array dimensions}{dynamic number of array dimensions} \\
\DWATrecursiveTARG
-&\livelinki{chap:DWATrecursiverecursivepropertyofasubroutine}{Recursive property of a subroutine}{recursive property of a subroutine} \\
+&\livelinki{chap:DWATrecursiverecursivepropertyofasubroutine}
+ {Recursive property of a subroutine}
+ {recursive property of a subroutine} \\
\DWATreferenceTARG
&\livelink{chap:DWATreferenceofnonstaticmember}
{\&-qualified non-static member function} \textit{(\addtoindex{C++})} \\
{String length of string type}
{string length of string type} \\
\DWATstringlengthbitsizeTARG
-&\livelinki{chap:DWATstringlengthstringlengthofstringtype}{Size of string length of string type}{string length of string type!size of}
- \\
+&\livelinki{chap:DWATstringlengthstringlengthofstringtype}
+ {Size of string length of string type}
+ {string length of string type!size of} \\
\DWATstringlengthbytesizeTARG
-&\livelinki{chap:DWATstringlengthstringlengthofstringtype}{Size of string length of string type}{string length of string type!size of}
- \\
+&\livelinki{chap:DWATstringlengthstringlengthofstringtype}
+ {Size of string length of string type}
+ {string length of string type!size of} \\
\DWATstroffsetsbaseTARG
&\livelinki{chap:DWATstroffsetbaseforindirectstringtable}{Base of string offsets table}{string offsets table} \\
\DWATthreadsscaledTARG
\DWATupperboundTARG
&\livelinki{chap:DWATupperboundupperboundofsubrange}{Upper bound of subrange}{upper bound of subrange} \\
\DWATuselocationTARG
-&\livelinki{chap:DWATuselocationmemberlocationforpointertomembertype}{Member location for pointer to member type}{member location for pointer to member type} \\
+&\livelinki{chap:DWATuselocationmemberlocationforpointertomembertype}
+ {Member location for pointer to member type}
+ {member location for pointer to member type} \\
\DWATuseUTFeightTARG\addtoindexx{use UTF8 attribute}\addtoindexx{UTF-8}
-&\livelinki{chap:DWATuseUTF8compilationunitusesutf8strings}{Compilation unit uses UTF-8 strings}{compilation unit uses UTF-8 strings} \\
+&\livelinki{chap:DWATuseUTF8compilationunitusesutf8strings}
+ {Compilation unit uses UTF-8 strings}
+ {compilation unit uses UTF-8 strings} \\
\DWATvariableparameterTARG
-&\livelinki{chap:DWATvariableparameternonconstantparameterflag}{Non-constant parameter flag}{non-constant parameter flag} \\
+&\livelinki{chap:DWATvariableparameternonconstantparameterflag}
+ {Non-constant parameter flag}
+ {non-constant parameter flag} \\
\DWATvirtualityTARG
&\livelinki{chap:DWATvirtualityvirtualityindication}{Virtuality indication}{virtuality indication} \\
&\livelinki{chap:DWATvirtualityvirtualityofbaseclass}{Virtuality of base class} {virtuality of base class} \\
\DWATvisibilityTARG
&\livelinki{chap:DWATvisibilityvisibilityofdeclaration}{Visibility of declaration}{visibility of declaration} \\
\DWATvtableelemlocationTARG
-&\livelinki{chap:DWATvtableelemlocationvirtualfunctiontablevtableslot}{Virtual function vtable slot}{virtual function vtable slot}\\
+&\livelinki{chap:DWATvtableelemlocationvirtualfunctiontablevtableslot}
+ {Virtual function vtable slot}
+ {virtual function vtable slot}\\
\end{longtable}
\addtoindexx{address|see {\textit{also} address class}}
the unit containing the reference. The third type of reference
is an indirect reference to a
\addtoindexx{type signature}
-type definition using a 64\dash bit \mbox{signature}
+type definition using a 64-bit \mbox{signature}
for that 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
\textit{%
For example, if a particular target architecture supports
-both 32\dash bit and 64\dash bit addresses, the compiler will generate
+both 32-bit and 64-bit addresses, the compiler will generate
an object file which specifies that it contains executable
code generated for one or the other of these
\addtoindexx{size of an address}
\itembfnl{\DWOPconstoneuTARG, \DWOPconsttwouTARG, \DWOPconstfouruTARG, \DWOPconsteightuTARG}
\DWOPconstnxMARK{}
The single operand of a \DWOPconstnuNAME{} operation provides a 1,
-2, 4, or 8\dash byte unsigned integer constant, respectively.
+2, 4, or 8-byte unsigned integer constant, respectively.
\itembfnl{\DWOPconstonesTARG, \DWOPconsttwosTARG, \DWOPconstfoursTARG, \DWOPconsteightsTARG}
The single operand of a \DWOPconstnsNAME{} operation provides a 1,
-2, 4, or 8\dash byte signed integer constant, respectively.
+2, 4, or 8-byte signed integer constant, respectively.
\itembfnl{\DWOPconstuTARG}
The single operand of the \DWOPconstuNAME{} operation provides
interpreted by the consumer as a relocatable address
(for example, offsets to thread-local storage).}
+\needlines{12}
\itembfnl{\DWOPconsttypeTARG}
The \DWOPconsttypeNAME{} operation takes three operands. The first operand
is an unsigned LEB128 integer that represents the offset of a debugging
which is specified by an unsigned LEB128\addtoindexx{LEB128!unsigned}
number, followed by a signed LEB128\addtoindexx{LEB128!signed} offset.
+\needlines{8}
\itembfnl{\DWOPregvaltypeTARG}
The \DWOPregvaltypeNAME{} operation takes two operands. The first
operand is an unsigned LEB128\addtoindexx{LEB128!unsigned} number,
\itembfnl{\DWOPpickTARG}
The single operand of the \DWOPpickNAME{} operation provides a
-1\dash byte index. A copy of the stack entry (including its
+1-byte index. A copy of the stack entry (including its
type identifier) with the specified
index (0 through 255, inclusive) is pushed onto the stack.
This is equivalent to a
\DWOPpick{} operation, with index 1.
+\needlines{4}
\itembfnl{\DWOPswapTARG}
The \DWOPswapNAME{} operation swaps the top two stack entries.
The entry at the top of the stack (including its type identifier)
special address type identifier. In
the \DWOPderefsizeNAME{} 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
+specified by the single operand. This operand is a 1-byte
unsigned integral constant whose value may not be larger
than the \addtoindex{size of an address} on the target machine. The data
retrieved is zero extended to the size of an address on the
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
-1\dash byte unsigned integral constant whose value may not be larger
+1-byte unsigned integral constant whose value may not be larger
than the \addtoindex{size of an address} on the target machine. The data
retrieved is zero extended to the \addtoindex{size of an address} on the
target machine before being pushed onto the expression stack together
\needlines{6}
\itembfnl{\DWOPskipTARG}
\DWOPskipNAME{} is an unconditional branch. Its single operand
-is a 2\dash byte signed integer constant. The 2\dash byte constant is
+is a 2-byte signed integer constant. The 2-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.
+2-byte constant.
\itembfnl{\DWOPbraTARG}
\DWOPbraNAME{} is a conditional branch. Its single operand is a
-2\dash byte signed integer constant. This operation pops the
+2-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
+the 2-byte constant operand 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.
+operation, beginning after the 2-byte constant.
% The following item does not correctly hyphenate leading
% to an overfull hbox and a visible artifact.
DWARF procedure calls during evaluation of a DWARF expression or
location description.
For \DWOPcalltwoNAME{} and \DWOPcallfourNAME{},
-the operand is the 2\dash~ or 4\dash byte unsigned offset, respectively,
+the operand is the 2\dash~ or 4-byte unsigned offset, respectively,
of a debugging information entry in the current compilation
unit. The \DWOPcallrefNAME{} 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
+the operand is a 4-byte unsigned value;
+in the \sixtyfourbitdwarfformat, it is an 8-byte unsigned value
(see Section \referfol{datarep:32bitand64bitdwarfformats}).
The operand is used as the offset of a
debugging information entry in a
used to describe values that exist neither in memory nor in a
single register.}
-\paragraph{Empty Location Descriptions}
-
+\subsubsubsection{Empty Location Descriptions}
An \addtoindex{empty location description}
consists of a DWARF expression
\addtoindexx{location description!empty}
This entry indicates the end of a location list, and
contains no further data.
+\needlines{6}
\itembfnl{\DWLLEbaseaddressselectionentryTARG}
This entry contains an
unsigned LEB128\addtoindexx{LEB128!unsigned} value immediately
description follows the fields that define the address range.
\end{enumerate}
-
+\needlines{10}
\section{Types of Program Entities}
\label{chap:typesofprogramentities}
\hypertarget{chap:DWATtypetypeofdeclaration}{}
Name&Value&Meaning \\
\hline
\textit{DW\_ADDR\_none}& 0 & \textit{no class specified} \\
-\textit{DW\_ADDR\_near16}& 1 & \textit{16\dash bit offset, no segment} \\
-\textit{DW\_ADDR\_far16}& 2 & \textit{16\dash bit offset, 16\dash bit segment} \\
-\textit{DW\_ADDR\_huge16}& 3 & \textit{16\dash bit offset, 16\dash bit segment} \\
-\textit{DW\_ADDR\_near32}& 4 & \textit{32\dash bit offset, no segment} \\
-\textit{DW\_ADDR\_far32}& 5 & \textit{32\dash bit offset, 16\dash bit segment} \\
+\textit{DW\_ADDR\_near16}& 1 & \textit{16-bit offset, no segment} \\
+\textit{DW\_ADDR\_far16}& 2 & \textit{16-bit offset, 16-bit segment} \\
+\textit{DW\_ADDR\_huge16}& 3 & \textit{16-bit offset, 16-bit segment} \\
+\textit{DW\_ADDR\_near32}& 4 & \textit{32-bit offset, no segment} \\
+\textit{DW\_ADDR\_far32}& 5 & \textit{32-bit offset, 16-bit segment} \\
\hline
\end{tabular}
\end{table}
\addtoindexx{identifier names}
representing
\addtoindexx{names!identifier}
-a program entity
-that has been given a name may have a
-\DWATname{} attribute,
-whose
-\addtoindexx{name attribute}
-value is a \livelink{chap:classstring}{string}
-representing the name as it appears in
+a program entity that has been given a name may have a
+\DWATname{}
+attribute\addtoindexx{name attribute}, whose value of
+\CLASSstring{} represents the name as it appears in
the source program. A debugging information entry containing
no name attribute, or containing a name attribute whose value
consists of a name containing a single null byte, represents
\label{chap:linkagenames}
\textit{Some language implementations, notably
\addtoindex{C++} and similar
-languages,
-make use of implementation-defined names within
-object files that are different from the identifier names
-(see Section \refersec{chap:identifiernames}) of entities as they appear in the
-source. Such names, sometimes known
-\addtoindexx{names!mangled}
-as
-\addtoindex{mangled names},
+languages, make use of implementation-defined names within
+object files that are different from the \addtoindex{identifier names}
+(see Section \refersec{chap:identifiernames}) of entities as they
+appear in the source. Such names, sometimes known as
+\addtoindex{mangled names}\addtoindexx{names!mangled},
are used in various ways, such as: to encode additional
information about an entity, to distinguish multiple entities
that have the same name, and so on. When an entity has an
}
% Some trouble maybe with hbox full, so we try optional word breaks.
-A debugging
-information entry may have
+A debugging information entry may have
\addtoindexx{linkage name attribute}
a
\DWATlinkagename{}
-attribute
-whose value is a null-terminated string describing the object
-file linkage name associated with the corresponding entity.
+attribute whose value is a null-terminated string containing the
+object file linkage name associated with the corresponding entity.
% Some trouble here with hbox full, so we try optional word breaks.
\textit{Debugging information entries to which \DWATlinkagename{}
\item Type hash, an 8-byte hash of the type declaration.
\end{itemize}
+\needlines{6}
It is possible that an indexed DIE has a parent that is not
indexed (for example, if its parent does not have a name attribute). In
such a case, a parent attribute may point to a nameless index
The length of this contribution to the name index section,
not including the length field itself.
-\item \texttt{version} (\addtoindex{uhalf}) \\
+\item \texttt{version} (\HFTuhalf) \\
A version number\addtoindexx{version number!name index table}
(see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
This number is specific to the name index table and is
independent of the DWARF version number.
-\item \textit{padding} (\addtoindex{uhalf}) \\
+\item \textit{padding} (\HFTuhalf) \\
+Reserved to DWARF.
-\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
\end{enumerate}
\subsubsubsection{List of CUs}
-
The list of CUs immediately follows the header. Each entry in the list
is a section offset. In the DWARF-32 format, a section offset is 4
bytes, while in the DWARF-64 format, a section offset is 8 bytes.
There must be at least one CU.
\subsubsubsection{List of Local TUs}
-
The list of local TUs immediately follows the list of CUs. Each entry
in the list is a section offset. In the DWARF-32 format, a section
offset is 4 bytes, while in the DWARF-64 format, a section offset is 8
\texttt{local\_type\_unit\_count}. This list may be empty.
\subsubsubsection{List of Foreign TUs}
-
The list of foreign TUs immediately follows the list of local TUs.
Each entry in the list is an 8-byte type signature (as described by
\DWFORMrefsigeight).
The number of entries in the list is given by \texttt{foreign\_type\_unit\_count}.
This list may be empty.
+\needlines{4}
\subsubsubsection{Hash Lookup Table}
-
The optional hash lookup table immediately follows the list of type signatures.
The hash lookup table is actually two separate arrays: an array of
in the name table.
\subsubsubsection{Name Table}
-
The name table immediately follows the hash lookup table. The name
table is laid out in column-major order (that is, the first column,
followed by the second column). Each entry in the first column
requirement for the name table.
\subsubsubsection{Abbreviations Table}
-
The abbreviations table immediately follows the name table. Like the
abbreviations table for debugging information entries, this table
consists of a series of abbreviation declarations. Its size is given
terminating 0 byte.
\subsubsubsection{Entry Pool}
-
The entry pool immediately follows the abbreviations table. The second
column of each row of the name table points to an offset in the entry
pool, where a series of index entries for that name is located.
The length of this contribution to the address lookup section,
not including the length field itself.
-\item \texttt{version} (\addtoindex{uhalf}) \\
+\item \texttt{version} (\HFTuhalf) \\
A version number\addtoindexx{version number!address lookup table}
(see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
This number is specific to the address lookup table and is
beginning of the \dotdebuginfo{} section of the
compilation unit header referenced by the set.
-\item \texttt{address\_size} (\addtoindex{ubyte}) \\
+\item \texttt{address\_size} (\HFTubyte) \\
The \addtoindex{size of an address}
in bytes on
\addttindexx{address\_size}
segmented addressing, this is
the size of the offset portion of the address.
-\item \texttt{segment\_size} (\addtoindex{ubyte}) \\
+\item \texttt{segment\_size} (\HFTubyte) \\
The size of a segment selector in
\addttindexx{segment\_size}
bytes on the target architecture. If the target system uses
and
MIPS architectures support
\addtoindexx{MIPS instruction set architecture}
-a 32\dash bit as well as a 16\dash bit instruction set). Because the
+a 32-bit as well as a 16-bit instruction set). Because the
instruction set is a function of the program counter, it is
convenient to encode the applicable instruction set in the
\dotdebugline{} section as well.}
\begin{enumerate}[1. ]
\item special opcodes \\
-These have a \addtoindex{ubyte} opcode field and no operands.\vspace{1ex}
+These have a \HFTubyte opcode field and no operands.\vspace{1ex}
\textit{Most of the instructions in a
line number program are special opcodes.}
\item standard opcodes \\
-These have a \addtoindex{ubyte} opcode field which may be followed by zero or more
+These have a \HFTubyte opcode field which may be followed by zero or more
\addtoindex{LEB128} operands (except for
\mbox{\DWLNSfixedadvancepc,} see below).
The opcode implies the number of operands and their meanings, but the
These have a multiple byte format. The first byte is zero; the next bytes
are an unsigned LEB128\addtoindexx{LEB128!unsigned} integer giving the number of bytes in the
instruction itself (does not include the first zero byte or the size). The
-remaining bytes are the instruction itself (which begins with a \addtoindex{ubyte}
+remaining bytes are the instruction itself (which begins with a \HFTubyte
extended opcode). \\
\end{enumerate}
compilation unit, not including the length field itself
(see Section \refersec{datarep:initiallengthvalues}).
-\item \texttt{version} (\addtoindex{uhalf}) \\
+\item \texttt{version} (\HFTuhalf) \\
A version number\addtoindexx{version number!line number information}
(see Section \refersec{datarep:linenumberinformation}).
This number is specific to
the line number information and is independent of the DWARF
version number.
-\item \texttt{address\_size} (ubyte)\\
+\item \texttt{address\_size} (\HFTubyte)\\
A 1-byte unsigned integer containing the size in bytes of an
address (or offset portion of an address for segmented addressing)
on the target system.
the line number sections (\dotdebugline{} and \dotdebuglinestr{})
from an executable.}
-\item \texttt{segment\_size} (ubyte) \\
+\item \texttt{segment\_size} (\HFTubyte) \\
\addttindexx{segment\_size}
A 1-byte unsigned integer containing the size in bytes of a segment
selector on the target system.
\item \texttt{header\_length} \\
The number of bytes following the \addttindex{header\_length} field to the
beginning of the first byte of the line number program itself.
-In the \thirtytwobitdwarfformat, this is a 4\dash byte unsigned
+In the \thirtytwobitdwarfformat, this is a 4-byte unsigned
length; in the \sixtyfourbitdwarfformat, this field is an
-8\dash byte unsigned length
+8-byte unsigned length
(see Section \refersec{datarep:32bitand64bitdwarfformats}).
-\item \texttt{minimum\_instruction\_length} (\addtoindex{ubyte}) \\
+\item \texttt{minimum\_instruction\_length} (\HFTubyte) \\
\addttindexx{minimum\_instruction\_length}
The size in bytes of the smallest target machine
instruction. Line number program opcodes that alter
(see following) in their calculations.
\needlines{9}
-\item \texttt{maximum\_operations\_per\_instruction} (\addtoindex{ubyte}) \\
+\item \texttt{maximum\_operations\_per\_instruction} (\HFTubyte) \\
The
\addttindexx{maximum\_operations\_per\_instruction}
maximum number of individual operations that may be
0, and the operation pointer is simply the \texttt{address} register.
\needlines{4}
-\item \texttt{default\_is\_stmt} (\addtoindex{ubyte}) \\
+\item \texttt{default\_is\_stmt} (\HFTubyte) \\
\addttindexx{default\_is\_stmt}
The initial value of the \addttindex{is\_stmt} register.
be either \doublequote{true} or \doublequote{false.} This approach might be
used as part of support for debugging optimized code.}
-\item \texttt{line\_base} (\addtoindex{sbyte}) \\
+\item \texttt{line\_base} (\HFTsbyte) \\
\addttindexx{line\_base}
This parameter affects the meaning of the special opcodes. See below.
-\item \texttt{line\_range} (\addtoindex{ubyte}) \\
+\item \texttt{line\_range} (\HFTubyte) \\
\addttindexx{line\_range}
This parameter affects the meaning of the special opcodes. See below.
\needlines{4}
-\item \texttt{opcode\_base} (\addtoindex{ubyte}) \\
+\item \texttt{opcode\_base} (\HFTubyte) \\
The
\addttindexx{opcode\_base}
number assigned to the first special opcode.
opcode (not inclusive) are used for vendor specific extensions.}
\needlines{4}
-\item \texttt{standard\_opcode\_lengths} (array of \addtoindex{ubyte}) \\
+\item \texttt{standard\_opcode\_lengths} (array of \HFTubyte) \\
\addttindexx{standard\_opcode\_lengths}
This array specifies the number of \addtoindex{LEB128} operands for each
of the standard opcodes. The first element of the array
\begin{enumerate}[1. ]
%%% Resume enumeration count where it left off above
\setcounter{enumi}{\value{saveenumi}}
-\item \texttt{directory\_entry\_format\_count} (ubyte) \\
+\item \texttt{directory\_entry\_format\_count} (\HFTubyte) \\
\addttindexx{directory\_entry\_format\_count}
A count of the number of entries that occur in the
following \addttindex{directory\_entry\_format} field.
both the compilation unit DIE and the line number header can
share a single copy of the current directory name string.}
-\item \texttt{file\_name\_entry\_format\_count} (ubyte) \\
+\item \texttt{file\_name\_entry\_format\_count} (\HFTubyte) \\
\addttindexx{file\_name\_entry\_format\_count}
A count of the number of file entry format entries that
occur in the following \addttindex{file\_name\_entry\_format} field.
\subsubsection{Special Opcodes}
\label{chap:specialopcodes}
-Each \addtoindex{ubyte} special opcode has the following effect on the state machine:
+Each \HFTubyte special opcode has the following effect on the state machine:
\begin{enumerate}[1. ]
\item \textbf{\DWLNSfixedadvancepcTARG} \\
The \DWLNSfixedadvancepcTARG{} opcode
-takes a single \addtoindex{uhalf} (unencoded) operand and adds it to the
+takes a single \HFTuhalf (unencoded) operand and adds it to the
\texttt{address} register of the state machine and sets the \addttindex{op\_index}
register to 0. This is the only standard opcode whose operand
is \textbf{not} a variable length number. It also does
The macro information header contains the following fields:
\begin{enumerate}[1. ]
-\item \texttt{version} (uhalf) \\
+\item \texttt{version} (\HFTuhalf) \\
A version number (see Section \refersec{datarep:macroinformation}).
This number is specific to the macro information and is independent
of the DWARF version number.
-\item \texttt{flags} (ubyte) \\
+\item \texttt{flags} (\HFTubyte) \\
The bits of the \texttt{flags} field are interpreted as a set
of flags, some of which may indicate that additional fields follow.
The following flags, beginning with the least significant bit, are defined:
\end{tabular}
\end{table}
+\needlines{6}
\subsubsection{Define and Undefine Entries}
\label{chap:defineandundefineentries}
The define and undefine macro entries have multiple forms that
While described in pairs below, the forms of define
and undefine entries may be freely intermixed.
+\needlines{6}
\subsubsubsection{Define and Undefine Using Direct Strings}
\label{chap:defineandundefinedirectentries}
A \DWMACROdefineTARG{} or
\item \texttt{CIE\_id} (4 or 8 bytes, see Section \refersec{datarep:32bitand64bitdwarfformats}) \\
A constant that is used to distinguish CIEs from FDEs.
-\item \texttt{version} (\addtoindex{ubyte}) \\
+\item \texttt{version} (\HFTubyte) \\
A version number\addtoindexx{version number!call frame information}
(see Section \refersec{datarep:callframeinformation}).
This number is specific to the call frame information
and is independent of the DWARF version number.
\needlines{8}
-\item \texttt{augmentation} (\addtoindex{UTF\dash 8} string) \\
+\item \texttt{augmentation} (\HFTaugstring) \\
A null\dash terminated UTF\dash 8 string that identifies the augmentation
to this CIE or to the FDEs that use it. If a reader encounters
an augmentation string that is unexpected, then only the
UTF\dash 8 encoding.}
\needlines{4}
-\item \texttt{address\_size} (\addtoindex{ubyte}) \\
+\item \texttt{address\_size} (\HFTubyte) \\
The size of a target address
\addttindexx{address\_size}
in this CIE and any FDEs that
use it, in bytes. If a compilation unit exists for this frame,
its address size must match the address size here.
-\item \texttt{segment\_size} (\addtoindex{ubyte}) \\
+\item \texttt{segment\_size} (\HFTubyte) \\
The \addttindexx{segment\_size}
size of a segment selector in this CIE and any FDEs that
use it, in bytes.
register.
\needlines{8}
-\item \texttt{initial\_instructions} (array of \addtoindex{ubyte}) \\
+\item \texttt{initial\_instructions} (array of \HFTubyte) \\
A sequence of rules that are interpreted to create the initial
setting of each column in the table.
compilation system authoring body may specify an alternate
default value for any or all columns.
-\item \texttt{padding} (array of \addtoindex{ubyte}) \\
+\item \texttt{padding} (array of \HFTubyte) \\
Enough \DWCFAnop{} instructions to make the size of this entry
match the length value above.
\end{enumerate}
\addtoindexx{target address}
of bytes of program instructions described by this entry.
-\item \texttt{instructions} (array of \addtoindex{ubyte}) \\
+\item \texttt{instructions} (array of \HFTubyte) \\
A sequence of table defining instructions that are described below.
-\item \texttt{padding} (array of \addtoindex{ubyte}) \\
+\item \texttt{padding} (array of \HFTubyte) \\
Enough \DWCFAnop{} instructions
to make the size of this entry match the length value above.
\end{enumerate}
current row
\item \textbf{\DWCFAadvanceloconeTARG{}} \\
-The \DWCFAadvanceloconeTARG{} instruction takes a single \addtoindex{ubyte}
+The \DWCFAadvanceloconeTARG{} instruction takes a single \HFTubyte
operand that represents a constant delta. This instruction
is identical to \DWCFAadvanceloc{} except for the encoding
and size of the delta operand.
\needlines{6}
\item \textbf{\DWCFAadvanceloctwoTARG} \\
The \DWCFAadvanceloctwoTARG{} instruction takes a single
-\addtoindex{uhalf}
+\HFTuhalf
operand that represents a constant delta. This instruction
is identical to \DWCFAadvanceloc{} except for the encoding
and size of the delta operand.
\item \textbf{\DWCFAadvancelocfourTARG} \\
The \DWCFAadvancelocfourTARG{} instruction takes a single
-\addtoindex{uword}
+\HFTuword
operand that represents a constant delta. This instruction
is identical to \DWCFAadvanceloc{} except for the encoding
and size of the delta operand.
DWARF Git Projects / dwarf-doc.git / commitdiff