This completes all review processing.
Signed-off-by: Ron Brender <ron.brender@gmail.com>
\livetarg{chap:DECL}
means include all three of the
\addtoindex{declaration coordinates}
-\addtoindexx{declaration coordinates|see {DW\_AT\_decl\_file,DW\_AT\_decl\_line, DW\_AT\_decl\_column}}
+\addtoindexx{declaration coordinates|see {DW\_AT\_decl\_file, DW\_AT\_decl\_line, DW\_AT\_decl\_column}}
\livelink{chap:DWATdeclcolumn}{DW\_AT\_decl\_column},
\livelink{chap:DWATdeclfile}{DW\_AT\_decl\_file}, and
\livelink{chap:DWATdeclline}{DW\_AT\_decl\_line}.
\dotdebugtypes{}
\end{alltt}
+\needlines{5}
As discussed in the previous section
(Section \refersec{app:usingcompilationunits}),
many
given entity. The DWARF description, and everything else for
this function, should be reduced to just a single copy.
+\needlines{5}
For each such code group (function template in this example)
the compiler assigns a name for the group which will match
all other instantiations of this function but match nothing
\hypertarget{chap:DWATexternalexternalvariable}
which
\addtoindexx{external attribute}
-is a \livelink{chap:flag}{flag}, if the name
+is a \livelink{chap:classflag}{flag}, if the name
of a variable is visible outside of its enclosing compilation
unit.
\item A \livelink{chap:DWATdeclaration}{DW\_AT\_declaration} attribute,
\addtoindexx{declaration attribute}
-which is a \livelink{chap:flag}{flag} that
+which is a \livelink{chap:classflag}{flag} that
indicates whether this entry represents a non-defining
declaration of an object.
\item If the variable entry represents the defining declaration
for a C++ static data member of a structure, class or union,
the entry has a \livelink{chap:DWATspecification}{DW\_AT\_specification} attribute, whose value is a
-reference to the debugging information entry representing the
+\livelink{chap:class:reference}{reference} to the debugging information entry representing the
declaration of this data member. The referenced entry has the
tag \livelink{chap:DWTAGmember}{DW\_TAG\_member} and will be a child of some class, structure
or union type entry.
\item A \livelink{chap:DWATvariableparameter}{DW\_AT\_variable\_parameter}
attribute\addtoindexx{variable parameter attribute},
-which is a \livelink{chap:flag}{flag},
+which is a \livelink{chap:classflag}{flag},
if a formal parameter entry represents a parameter whose
value in the calling function may be modified by the callee.
The absence of this attribute implies that the parameter\textquoteright s
\hypertarget{chap:DWATisoptionaloptionalparameter}
which
\addtoindexx{is optional attribute}
-is a \livelink{chap:flag}{flag}, if a
+is a \livelink{chap:classflag}{flag}, if a
parameter entry represents an \addtoindex{optional parameter}.
\item A \livelink{chap:DWATdefaultvalue}{DW\_AT\_default\_value} attribute
that is not a base selection entry or an end of list entry.
\item Otherwise, the scope of the object is specified using
-a value of class \livelink{chap:rangelistptr}{rangelistptr}.
+a value of class \livelink{chap:classrangelistptr}{rangelistptr}.
This value indicates the
beginning of a \addtoindex{range list}
(see \refersec{chap:noncontiguousaddressranges}).
\item A \livelink{chap:DWATconstexpr}{DW\_AT\_const\_expr} attribute,
which
\hypertarget{chap:DWATconstexprcompiletimeconstantobject}
-is a \livelink{chap:flag}{flag}, if a
+is a \livelink{chap:classflag}{flag}, if a
variable entry represents a C++ object declared with the
\texttt{constexpr} specifier. This attribute indicates that the
variable can be evaluated as a compile\dash time constant.
\textit{In C++,
a variable declared with \texttt{constexpr} is implicitly \texttt{const}. Such a
-variable has a \livelink{chap:DWATtype}{DW\_AT\_type} attribute whose value is a reference
+variable has a \livelink{chap:DWATtype}{DW\_AT\_type} attribute whose value is a
+\livelink{chap:classreference}{reference}
to a debugging information entry describing a const qualified type.}
\item A \livelink{chap:DWATlinkagename}{DW\_AT\_linkage\_name} attribute for a
\addtoindexx{namelist item attribute}
whose
\addtoindexx{namelist item entry}
-value is a reference to the debugging
+value is a \livelink{chap:classreference}{reference} to the debugging
information entry representing the declaration of the item
whose name appears in the namelist.
value range for vendor specific extensions consist of the
appropriate prefix (DW\_TAG, DW\_AT, DW\_END, DW\_ATE, DW\_OP,
DW\_LANG, DW\_LNE, DW\_CC or DW\_CFA respectively) followed by
-\livetarg{chap:DWXXXlohiuser}
+\hypertarget{chap:DWXXXlohiuser}{}
\_lo\_user or \_hi\_user.
\textit{For example, for entry tags, the special
labels are DW\_TAG\_lo\_user and DW\_TAG\_hi\_user.}
\begin{enumerate}[1. ]
\item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
-\addtoindexx{\texttt{unit\_length}}
+\addttindexx{unit\_length}
A 4\dash byte or 12\dash byte
\addtoindexx{initial length}
unsigned integer representing the length
(see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
The value in this field is 4.
-\item \addtoindex{\texttt{debug\_abbrev\_offset}} (\livelink{datarep:sectionoffsetlength}{section offset}) \\
+\item \addttindex{debug\_abbrev\_offset} (\livelink{datarep:sectionoffsetlength}{section offset}) \\
A
\addtoindexx{section offset!in .debug\_info header}
4\dash byte or 8\dash byte unsigned offset into the
\item \texttt{address\_size} (\addtoindex{ubyte}) \\
A 1\dash byte unsigned integer representing the size in bytes of
-\addtoindexx{\texttt{address\_size}}
+\addttindexx{address\_size}
an address on the target architecture. If the system uses
\addtoindexx{address space!segmented}
segmented addressing, this value represents the size of the
\begin{enumerate}[1. ]
\item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
-\addtoindexx{\texttt{unit\_length}}
+\addttindexx{unit\_length}
A 4\dash byte or 12\dash byte unsigned integer
\addtoindexx{initial length}
representing the length
(see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
The value in this field is 4.
-\item \addtoindex{\texttt{debug\_abbrev\_offset}} (\livelink{datarep:sectionoffsetlength}{section offset}) \\
+\item \addttindex{debug\_abbrev\_offset} (\livelink{datarep:sectionoffsetlength}{section offset}) \\
A
\addtoindexx{section offset!in .debug\_types header}
4\dash byte or 8\dash byte unsigned offset into the
A 1\dash byte unsigned integer representing the size
\addtoindexx{size of an address}
in bytes of
-\addtoindexx{\texttt{address\_size}}
+\addttindexx{address\_size}
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{type\_signature} (8\dash byte unsigned integer) \\
\addtoindexx{type signature}
A
-\addtoindexx{\texttt{type\_signature}}
+\addttindexx{type\_signature}
64\dash bit unique signature (see Section
\refersec{datarep:typesignaturecomputation})
of the type described in this type
\item \texttt{type\_offset} (\livelink{datarep:sectionoffsetlength}{section offset}) \\
-\addtoindexx{\texttt{type\_offset}}
+\addttindexx{type\_offset}
A 4\dash byte or 8\dash byte unsigned offset
\addtoindexx{section offset!in .debug\_types header}
relative to the beginning
\addtoindexx{loclistptr class}
class,
\addtoindexx{lineptr class}
-namely \livelink{chap:lineptr}{lineptr},
-\livelink{chap:loclistptr}{loclistptr},
-\livelink{chap:macptr}{macptr} or
-\livelink{chap:rangelistptr}{rangelistptr}; the list
+namely \livelink{chap:classlineptr}{lineptr},
+\livelink{chap:classloclistptr}{loclistptr},
+\livelink{chap:classmacptr}{macptr} or
+\livelink{chap:classrangelistptr}{rangelistptr}; the list
of classes allowed by the applicable attribute in
Table \refersec{tab:attributeencodings}
determines the class of the form.
\addtoindexx{loclistptr class}
class constant \addtoindexx{constant class}
or one of the classes
-\livelink{chap:lineptr}{lineptr},
-\livelink{chap:loclistptr}{loclistptr},
-\livelink{chap:macptr}{macptr} or
-\livelink{chap:rangelistptr}{rangelistptr}, depending on context. In
+\livelink{chap:classlineptr}{lineptr},
+\livelink{chap:classloclistptr}{loclistptr},
+\livelink{chap:classmacptr}{macptr} or
+\livelink{chap:classrangelistptr}{rangelistptr}, depending on context. In
DWARF V4
\livelink{chap:DWFORMdata4}{DW\_FORM\_data4} and
\livelink{chap:DWFORMdata8}{DW\_FORM\_data8} are members of class
Each possible form belongs to one or more of the following classes:
\begin{itemize}
-\item \livelinki{chap:DWATaddressclass}{address}{address class} \\
+\item \livelinki{chap:classaddress}{address}{address class} \\
+\livetarg{datarep:classaddress}{}
Represented as an object of appropriate size to hold an
address on the target machine
(\livetarg{chap:DWFORMaddr}{DW\_FORM\_addr}).
This address is relocatable in a relocatable object file and
is relocated in an executable file or shared object.
-\item \livelink{chap:block}{block} \\
+\item \livelink{chap:classblock}{block} \\
+\livetarg{datarep:classblock}{}
Blocks come in four forms:
\begin{myindentpara}{1cm}
bytes (\livetarg{chap:DWFORMblock2}{DW\_FORM\_block2}).
\end{myindentpara}
-
\begin{myindentpara}{1cm}
A 4\dash byte length followed by 0 to 4,294,967,295 contiguous
information bytes (\livetarg{chap:DWFORMblock4}{DW\_FORM\_block4}).
\end{myindentpara}
-
\begin{myindentpara}{1cm}
An unsigned LEB128 length followed by the number of bytes
specified by the length (\livetarg{chap:DWFORMblock}{DW\_FORM\_block}).
of relocated (or relocatable) addresses, references to other
debugging information entries or data bytes.
-\item constant \\
+\item \livelinki{chap:classconstant}{constant}{constant class} \\
+\livetarg{datarep:classconstant}{}
There are six forms of constants. There are fixed length
constant data forms for one, two, four and eight byte values
(respectively,
\livelink{chap:DWFORMdata}{DW\_FORM\_data}\textless n\textgreater.}
\needlines{4}
-\item \livelink{chap:exprloc}{exprloc} \\
+\item \livelinki{chap:classexprloc}{exprloc}{exprloc class} \\
+\livetarg{datarep:classexprloc}{}
This is an unsigned LEB128 length followed by the
number of information bytes specified by the length
(\livetarg{chap:DWFORMexprloc}{DW\_FORM\_exprloc}).
-The information bytes contain a DWARF
-expression
+The information bytes contain a DWARF expression
(see Section \refersec{chap:dwarfexpressions})
or location description
(see Section \refersec{chap:locationdescriptions}).
-\item \livelink{chap:flag}{flag} \\
+\item \livelinki{chap:classflag}{flag}{flag class} \\
+\livetarg{datarep:classflag}{}
A flag \addtoindexx{flag class}
is represented explicitly as a single byte of data
(\livetarg{chap:DWFORMflag}{DW\_FORM\_flag}) or
case, the attribute is implicitly indicated as present, and
no value is encoded in the debugging information entry itself.
-\item \livelink{chap:lineptr}{lineptr} \\
+\item \livelinki{chap:classlineptr}{lineptr}{lineptr class} \\
+\livetarg{datarep:classlineptr}{}
This is an offset into
\addtoindexx{section offset!in class lineptr value}
the
\dotdebugline{} section
(\livelink{chap:DWFORMsecoffset}{DW\_FORM\_sec\_offset}).
-It consists of an offset from the
-beginning of the
+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
(see Section \refersec{datarep:32bitand64bitdwarfformats}).
-\item \livelink{chap:loclistptr}{loclistptr} \\
+\item \livelinki{chap:classloclistptr}{loclistptr}{loclistptr class} \\
+\livetarg{datarep:classloclistptr}{}
This is an offset into the
\dotdebugloc{}
section
\dotdebugloc{}
section to the first byte of
the data making up the
-\addtoindex{location list} for the compilation
-unit.
+\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;
(see Section \refersec{datarep:32bitand64bitdwarfformats}).
-\item \livelink{chap:macptr}{macptr} \\
+\item \livelinki{chap:classmacptr}{macptr}{macptr class} \\
+\livetarg{datarep:classmacptr}{}
This is an
\addtoindexx{section offset!in class macptr value}
offset into the
(see Section \refersec{datarep:32bitand64bitdwarfformats}).
\needlines{4}
-\item \livelink{chap:rangelistptr}{rangelistptr} \\
+\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
\refersec{datarep:32bitand64bitdwarfformats}).
\end{itemize}
-\textit{Because classes \livelink{chap:lineptr}{lineptr},
-\livelink{chap:loclistptr}{loclistptr},
-\livelink{chap:macptr}{macptr} and
-\livelink{chap:rangelistptr}{rangelistptr}
+\textit{Because classes \livelink{chap:classlineptr}{lineptr},
+\livelink{chap:classloclistptr}{loclistptr},
+\livelink{chap:classmacptr}{macptr} and
+\livelink{chap:classrangelistptr}{rangelistptr}
share a common representation, it is not possible for an
attribute to allow more than one of these classes}
\begin{itemize}
-\item reference \\
+\item \livelinki{chap:classreference}{reference}{reference class} \\
+\livetarg{datarep:classreference}{}
There are three types of reference.
The
debugging information entry for that unit, not the preceding
header.}
-\item string \\
+\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}
\addtoindexx{lineptr class}
the
\addtoindexx{macptr class}
-classes \livelink{chap:lineptr}{lineptr},
-\livelink{chap:loclistptr}{loclistptr}, \livelink{chap:macptr}{macptr} or
-\livelink{chap:rangelistptr}{rangelistptr} to point into either the
+classes \livelink{chap:classlineptr}{lineptr},
+\livelink{chap:classloclistptr}{loclistptr}, \livelink{chap:classmacptr}{macptr} or
+\livelink{chap:classrangelistptr}{rangelistptr} to point into either the
\dotdebuginfo{} or \dotdebugstr{} section.
The form encodings are listed in
\hline
\ddag \ \textit{New in \addtoindex{DWARF Version 4}}
\endlastfoot
-\livelink{chap:DWATsibling}{DW\_AT\_sibling}&0x01&reference
+\livelink{chap:DWATsibling}{DW\_AT\_sibling}&0x01&\livelink{chap:classreference}{reference}
\addtoindexx{sibling attribute!encoding} \\
-\livelink{chap:DWATlocation}{DW\_AT\_location}&0x02&\livelink{chap:exprloc}{exprloc},
- \livelink{chap:loclistptr}{loclistptr}\addtoindexx{location attribute!encoding} \\
-\livelink{chap:DWATname}{DW\_AT\_name}&0x03&string
+\livelink{chap:DWATlocation}{DW\_AT\_location}&0x02&\livelink{chap:classexprloc}{exprloc},
+ \livelink{chap:classloclistptr}{loclistptr}\addtoindexx{location attribute!encoding} \\
+\livelink{chap:DWATname}{DW\_AT\_name}&0x03&\livelink{chap:classstring}{string}
\addtoindexx{name attribute!encoding} \\
-\livelink{chap:DWATordering}{DW\_AT\_ordering}&0x09&constant
+\livelink{chap:DWATordering}{DW\_AT\_ordering}&0x09&\livelink{chap:classconstant}{constant}
\addtoindexx{ordering attribute!encoding} \\
-\livelink{chap:DWATbytesize}{DW\_AT\_byte\_size}&0x0b&constant, \livelink{chap:exprloc}{exprloc},
- reference \addtoindexx{byte size attribute!encoding} \\
-\livelink{chap:DWATbitoffset}{DW\_AT\_bit\_offset}&0x0c&constant,
- \livelink{chap:exprloc}{exprloc}, reference \addtoindexx{bit offset attribute!encoding} \\
-\livelink{chap:DWATbitsize}{DW\_AT\_bit\_size}&0x0d&constant,
- \livelink{chap:exprloc}{exprloc}, reference \addtoindexx{bit size attribute!encoding} \\
-\livelink{chap:DWATstmtlist}{DW\_AT\_stmt\_list}&0x10&\livelink{chap:lineptr}{lineptr}
+\livelink{chap:DWATbytesize}{DW\_AT\_byte\_size}&0x0b&\livelink{chap:classconstant}{constant}, \livelink{chap:classexprloc}{exprloc},
+ \livelink{chap:classreference}{reference} \addtoindexx{byte size attribute!encoding} \\
+\livelink{chap:DWATbitoffset}{DW\_AT\_bit\_offset}&0x0c&\livelink{chap:classconstant}{constant},
+ \livelink{chap:classexprloc}{exprloc}, \livelink{chap:classreference}{reference} \addtoindexx{bit offset attribute!encoding} \\
+\livelink{chap:DWATbitsize}{DW\_AT\_bit\_size}&0x0d&\livelink{chap:classconstant}{constant},
+ \livelink{chap:classexprloc}{exprloc}, \livelink{chap:classreference}{reference} \addtoindexx{bit size attribute!encoding} \\
+\livelink{chap:DWATstmtlist}{DW\_AT\_stmt\_list}&0x10&\livelink{chap:classlineptr}{lineptr}
\addtoindexx{statement list attribute!encoding} \\
-\livelink{chap:DWATlowpc}{DW\_AT\_low\_pc}&0x11&address
+\livelink{chap:DWATlowpc}{DW\_AT\_low\_pc}&0x11&\livelink{chap:classaddress}{address}
\addtoindexx{low PC attribute!encoding} \\
-\livelink{chap:DWAThighpc}{DW\_AT\_high\_pc}&0x12&address, constant
+\livelink{chap:DWAThighpc}{DW\_AT\_high\_pc}&0x12&\livelink{chap:classaddress}{address}, \livelink{chap:classconstant}{constant}
\addtoindexx{high PC attribute!encoding} \\
-\livelink{chap:DWATlanguage}{DW\_AT\_language}&0x13&constant
+\livelink{chap:DWATlanguage}{DW\_AT\_language}&0x13&\livelink{chap:classconstant}{constant}
\addtoindexx{language attribute!encoding} \\
-\livelink{chap:DWATdiscr}{DW\_AT\_discr}&0x15&reference
+\livelink{chap:DWATdiscr}{DW\_AT\_discr}&0x15&\livelink{chap:classreference}{reference}
\addtoindexx{discriminant attribute!encoding} \\
-\livelink{chap:DWATdiscrvalue}{DW\_AT\_discr\_value}&0x16&constant
+\livelink{chap:DWATdiscrvalue}{DW\_AT\_discr\_value}&0x16&\livelink{chap:classconstant}{constant}
\addtoindexx{discriminant value attribute!encoding} \\
-\livelink{chap:DWATvisibility}{DW\_AT\_visibility}&0x17&constant
+\livelink{chap:DWATvisibility}{DW\_AT\_visibility}&0x17&\livelink{chap:classconstant}{constant}
\addtoindexx{visibility attribute!encoding} \\
-\livelink{chap:DWATimport}{DW\_AT\_import}&0x18&reference
+\livelink{chap:DWATimport}{DW\_AT\_import}&0x18&\livelink{chap:classreference}{reference}
\addtoindexx{import attribute!encoding} \\
-\livelink{chap:DWATstringlength}{DW\_AT\_string\_length}&0x19&\livelink{chap:exprloc}{exprloc},
- \livelink{chap:loclistptr}{loclistptr} \addtoindexx{string length attribute!encoding} \\
-\livelink{chap:DWATcommonreference}{DW\_AT\_common\_reference}&0x1a&reference
+\livelink{chap:DWATstringlength}{DW\_AT\_string\_length}&0x19&\livelink{chap:classexprloc}{exprloc},
+ \livelink{chap:classloclistptr}{loclistptr} \addtoindexx{string length attribute!encoding} \\
+\livelink{chap:DWATcommonreference}{DW\_AT\_common\_reference}&0x1a&\livelink{chap:classreference}{reference}
\addtoindexx{common reference attribute!encoding} \\
-\livelink{chap:DWATcompdir}{DW\_AT\_comp\_dir}&0x1b&string
+\livelink{chap:DWATcompdir}{DW\_AT\_comp\_dir}&0x1b&\livelink{chap:classstring}{string}
\addtoindexx{compilation directory attribute!encoding} \\
-\livelink{chap:DWATconstvalue}{DW\_AT\_const\_value}&0x1c&\livelink{chap:block}{block}, constant, string
+\livelink{chap:DWATconstvalue}{DW\_AT\_const\_value}&0x1c&\livelink{chap:classblock}{block}, \livelink{chap:classconstant}{constant}, \livelink{chap:classstring}{string}
\addtoindexx{constant value attribute!encoding} \\
-\livelink{chap:DWATcontainingtype}{DW\_AT\_containing\_type}&0x1d&reference
+\livelink{chap:DWATcontainingtype}{DW\_AT\_containing\_type}&0x1d&\livelink{chap:classreference}{reference}
\addtoindexx{containing type attribute!encoding} \\
-\livelink{chap:DWATdefaultvalue}{DW\_AT\_default\_value}&0x1e&reference
+\livelink{chap:DWATdefaultvalue}{DW\_AT\_default\_value}&0x1e&\livelink{chap:classreference}{reference}
\addtoindexx{default value attribute!encoding} \\
-\livelink{chap:DWATinline}{DW\_AT\_inline}&0x20&constant
+\livelink{chap:DWATinline}{DW\_AT\_inline}&0x20&\livelink{chap:classconstant}{constant}
\addtoindexx{inline attribute!encoding} \\
-\livelink{chap:DWATisoptional}{DW\_AT\_is\_optional}&0x21&\livelink{chap:flag}{flag}
+\livelink{chap:DWATisoptional}{DW\_AT\_is\_optional}&0x21&\livelink{chap:classflag}{flag}
\addtoindexx{is optional attribute!encoding} \\
-\livelink{chap:DWATlowerbound}{DW\_AT\_lower\_bound}&0x22&constant,
- \livelink{chap:exprloc}{exprloc}, reference \addtoindexx{lower bound attribute!encoding} \\
-\livelink{chap:DWATproducer}{DW\_AT\_producer}&0x25&string \addtoindexx{producer attribute!encoding} \\
-\livelink{chap:DWATprototyped}{DW\_AT\_prototyped}&0x27&\livelink{chap:flag}{flag}
+\livelink{chap:DWATlowerbound}{DW\_AT\_lower\_bound}&0x22&\livelink{chap:classconstant}{constant},
+ \livelink{chap:classexprloc}{exprloc}, \livelink{chap:classreference}{reference} \addtoindexx{lower bound attribute!encoding} \\
+\livelink{chap:DWATproducer}{DW\_AT\_producer}&0x25&\livelink{chap:classstring}{string} \addtoindexx{producer attribute!encoding} \\
+\livelink{chap:DWATprototyped}{DW\_AT\_prototyped}&0x27&\livelink{chap:classflag}{flag}
\addtoindexx{prototyped attribute!encoding} \\
-\livelink{chap:DWATreturnaddr}{DW\_AT\_return\_addr}&0x2a&\livelink{chap:exprloc}{exprloc},
- \livelink{chap:loclistptr}{loclistptr} \addtoindexx{return address attribute!encoding} \\
+\livelink{chap:DWATreturnaddr}{DW\_AT\_return\_addr}&0x2a&\livelink{chap:classexprloc}{exprloc},
+ \livelink{chap:classloclistptr}{loclistptr} \addtoindexx{return address attribute!encoding} \\
% FIXME: lower case , not Constant
-\livelink{chap:DWATstartscope}{DW\_AT\_start\_scope}&0x2c&constant,
- \livelink{chap:rangelistptr}{rangelistptr} \addtoindexx{start scope attribute!encoding} \\
-\livelink{chap:DWATbitstride}{DW\_AT\_bit\_stride}&0x2e&constant,
- \livelink{chap:exprloc}{exprloc}, reference \addtoindexx{bit stride attribute!encoding} \\
-\livelink{chap:DWATupperbound}{DW\_AT\_upper\_bound}&0x2f&constant,
- \livelink{chap:exprloc}{exprloc}, reference \addtoindexx{upper bound attribute!encoding} \\
-\livelink{chap:DWATabstractorigin}{DW\_AT\_abstract\_origin}&0x31&reference
+\livelink{chap:DWATstartscope}{DW\_AT\_start\_scope}&0x2c&\livelink{chap:classconstant}{constant},
+ \livelink{chap:classrangelistptr}{rangelistptr} \addtoindexx{start scope attribute!encoding} \\
+\livelink{chap:DWATbitstride}{DW\_AT\_bit\_stride}&0x2e&\livelink{chap:classconstant}{constant},
+ \livelink{chap:classexprloc}{exprloc}, \livelink{chap:classreference}{reference} \addtoindexx{bit stride attribute!encoding} \\
+\livelink{chap:DWATupperbound}{DW\_AT\_upper\_bound}&0x2f&\livelink{chap:classconstant}{constant},
+ \livelink{chap:classexprloc}{exprloc}, \livelink{chap:classreference}{reference} \addtoindexx{upper bound attribute!encoding} \\
+\livelink{chap:DWATabstractorigin}{DW\_AT\_abstract\_origin}&0x31&\livelink{chap:classreference}{reference}
\addtoindexx{abstract origin attribute!encoding} \\
-\livelink{chap:DWATaccessibility}{DW\_AT\_accessibility}&0x32&constant
+\livelink{chap:DWATaccessibility}{DW\_AT\_accessibility}&0x32&\livelink{chap:classconstant}{constant}
\addtoindexx{accessibility attribute!encoding} \\
-\livelink{chap:DWATaddressclass}{DW\_AT\_address\_class}&0x33&constant
+\livelink{chap:DWATaddressclass}{DW\_AT\_address\_class}&0x33&\livelink{chap:classconstant}{constant}
\addtoindexx{address class attribute!encoding} \\
-\livelink{chap:DWATartificial}{DW\_AT\_artificial}&0x34&\livelink{chap:flag}{flag}
+\livelink{chap:DWATartificial}{DW\_AT\_artificial}&0x34&\livelink{chap:classflag}{flag}
\addtoindexx{artificial attribute!encoding} \\
-\livelink{chap:DWATbasetypes}{DW\_AT\_base\_types}&0x35&reference
+\livelink{chap:DWATbasetypes}{DW\_AT\_base\_types}&0x35&\livelink{chap:classreference}{reference}
\addtoindexx{base types attribute!encoding} \\
-\livelink{chap:DWATcallingconvention}{DW\_AT\_calling\_convention}&0x36&constant
+\livelink{chap:DWATcallingconvention}{DW\_AT\_calling\_convention}&0x36&\livelink{chap:classconstant}{constant}
\addtoindexx{calling convention attribute!encoding} \\
-\livelink{chap:DWATcount}{DW\_AT\_count}&0x37&constant, \livelink{chap:exprloc}{exprloc}, reference
+\livelink{chap:DWATcount}{DW\_AT\_count}&0x37&\livelink{chap:classconstant}{constant}, \livelink{chap:classexprloc}{exprloc}, \livelink{chap:classreference}{reference}
\addtoindexx{count attribute!encoding} \\
-\livelink{chap:DWATdatamemberlocation}{DW\_AT\_data\_member\_location}&0x38&constant,
- \livelink{chap:exprloc}{exprloc}, \livelink{chap:loclistptr}{loclistptr}
+\livelink{chap:DWATdatamemberlocation}{DW\_AT\_data\_member\_location}&0x38&\livelink{chap:classconstant}{constant},
+ \livelink{chap:classexprloc}{exprloc}, \livelink{chap:classloclistptr}{loclistptr}
\addtoindexx{data member attribute!encoding} \\
-\livelink{chap:DWATdeclcolumn}{DW\_AT\_decl\_column}&0x39&constant
+\livelink{chap:DWATdeclcolumn}{DW\_AT\_decl\_column}&0x39&\livelink{chap:classconstant}{constant}
\addtoindexx{declaration column attribute!encoding} \\
-\livelink{chap:DWATdeclfile}{DW\_AT\_decl\_file}&0x3a&constant
+\livelink{chap:DWATdeclfile}{DW\_AT\_decl\_file}&0x3a&\livelink{chap:classconstant}{constant}
\addtoindexx{declaration file attribute!encoding} \\
-\livelink{chap:DWATdeclline}{DW\_AT\_decl\_line}&0x3b&constant
+\livelink{chap:DWATdeclline}{DW\_AT\_decl\_line}&0x3b&\livelink{chap:classconstant}{constant}
\addtoindexx{declaration line attribute!encoding} \\
-\livelink{chap:DWATdeclaration}{DW\_AT\_declaration}&0x3c&\livelink{chap:flag}{flag}
+\livelink{chap:DWATdeclaration}{DW\_AT\_declaration}&0x3c&\livelink{chap:classflag}{flag}
\addtoindexx{declaration attribute!encoding} \\
-\livelink{chap:DWATdiscrlist}{DW\_AT\_discr\_list}&0x3d&\livelink{chap:block}{block}
+\livelink{chap:DWATdiscrlist}{DW\_AT\_discr\_list}&0x3d&\livelink{chap:classblock}{block}
\addtoindexx{discriminant list attribute!encoding} \\
-\livelink{chap:DWATencoding}{DW\_AT\_encoding}&0x3e&constant
+\livelink{chap:DWATencoding}{DW\_AT\_encoding}&0x3e&\livelink{chap:classconstant}{constant}
\addtoindexx{encoding attribute!encoding} \\
-\livelink{chap:DWATexternal}{DW\_AT\_external}&\xiiif&\livelink{chap:flag}{flag}
+\livelink{chap:DWATexternal}{DW\_AT\_external}&\xiiif&\livelink{chap:classflag}{flag}
\addtoindexx{external attribute!encoding} \\
-\livelink{chap:DWATframebase}{DW\_AT\_frame\_base}&0x40&\livelink{chap:exprloc}{exprloc},
- \livelink{chap:loclistptr}{loclistptr} \addtoindexx{frame base attribute!encoding} \\
-\livelink{chap:DWATfriend}{DW\_AT\_friend}&0x41&reference
+\livelink{chap:DWATframebase}{DW\_AT\_frame\_base}&0x40&\livelink{chap:classexprloc}{exprloc},
+ \livelink{chap:classloclistptr}{loclistptr} \addtoindexx{frame base attribute!encoding} \\
+\livelink{chap:DWATfriend}{DW\_AT\_friend}&0x41&\livelink{chap:classreference}{reference}
\addtoindexx{friend attribute!encoding} \\
-\livelink{chap:DWATidentifiercase}{DW\_AT\_identifier\_case}&0x42&constant
+\livelink{chap:DWATidentifiercase}{DW\_AT\_identifier\_case}&0x42&\livelink{chap:classconstant}{constant}
\addtoindexx{identifier case attribute!encoding} \\
-\livelink{chap:DWATmacroinfo}{DW\_AT\_macro\_info}&0x43&\livelink{chap:macptr}{macptr}
+\livelink{chap:DWATmacroinfo}{DW\_AT\_macro\_info}&0x43&\livelink{chap:classmacptr}{macptr}
\addtoindexx{macro information attribute!encoding} \\
-\livelink{chap:DWATnamelistitem}{DW\_AT\_namelist\_item}&0x44&reference
+\livelink{chap:DWATnamelistitem}{DW\_AT\_namelist\_item}&0x44&\livelink{chap:classreference}{reference}
\addtoindexx{name list item attribute!encoding} \\
-\livelink{chap:DWATpriority}{DW\_AT\_priority}&0x45&reference
+\livelink{chap:DWATpriority}{DW\_AT\_priority}&0x45&\livelink{chap:classreference}{reference}
\addtoindexx{priority attribute!encoding} \\
-\livelink{chap:DWATsegment}{DW\_AT\_segment}&0x46&\livelink{chap:exprloc}{exprloc},
- \livelink{chap:loclistptr}{loclistptr} \addtoindexx{segment attribute!encoding} \\
-\livelink{chap:DWATspecification}{DW\_AT\_specification}&0x47&reference
+\livelink{chap:DWATsegment}{DW\_AT\_segment}&0x46&\livelink{chap:classexprloc}{exprloc},
+ \livelink{chap:classloclistptr}{loclistptr} \addtoindexx{segment attribute!encoding} \\
+\livelink{chap:DWATspecification}{DW\_AT\_specification}&0x47&\livelink{chap:classreference}{reference}
\addtoindexx{specification attribute!encoding} \\
-\livelink{chap:DWATstaticlink}{DW\_AT\_static\_link}&0x48&\livelink{chap:exprloc}{exprloc},
- \livelink{chap:loclistptr}{loclistptr} \addtoindexx{static link attribute!encoding} \\
-\livelink{chap:DWATtype}{DW\_AT\_type}&0x49&reference
+\livelink{chap:DWATstaticlink}{DW\_AT\_static\_link}&0x48&\livelink{chap:classexprloc}{exprloc},
+ \livelink{chap:classloclistptr}{loclistptr} \addtoindexx{static link attribute!encoding} \\
+\livelink{chap:DWATtype}{DW\_AT\_type}&0x49&\livelink{chap:classreference}{reference}
\addtoindexx{type attribute!encoding} \\
-\livelink{chap:DWATuselocation}{DW\_AT\_use\_location}&0x4a&\livelink{chap:exprloc}{exprloc},
- \livelink{chap:loclistptr}{loclistptr} \addtoindexx{location list attribute!encoding} \\
-\livelink{chap:DWATvariableparameter}{DW\_AT\_variable\_parameter}&0x4b&\livelink{chap:flag}{flag}
+\livelink{chap:DWATuselocation}{DW\_AT\_use\_location}&0x4a&\livelink{chap:classexprloc}{exprloc},
+ \livelink{chap:classloclistptr}{loclistptr} \addtoindexx{location list attribute!encoding} \\
+\livelink{chap:DWATvariableparameter}{DW\_AT\_variable\_parameter}&0x4b&\livelink{chap:classflag}{flag}
\addtoindexx{variable parameter attribute!encoding} \\
-\livelink{chap:DWATvirtuality}{DW\_AT\_virtuality}&0x4c&constant
+\livelink{chap:DWATvirtuality}{DW\_AT\_virtuality}&0x4c&\livelink{chap:classconstant}{constant}
\addtoindexx{virtuality attribute!encoding} \\
-\livelink{chap:DWATvtableelemlocation}{DW\_AT\_vtable\_elem\_location}&0x4d&\livelink{chap:exprloc}{exprloc},
- \livelink{chap:loclistptr}{loclistptr} \addtoindexx{vtable element location attribute!encoding} \\
-
-\livelink{chap:DWATallocated}{DW\_AT\_allocated}&0x4e&constant, \livelink{chap:exprloc}{exprloc},
- reference \addtoindexx{allocated attribute!encoding} \\
-\livelink{chap:DWATassociated}{DW\_AT\_associated}&0x4f&constant, \livelink{chap:exprloc}{exprloc},
- reference \addtoindexx{associated attribute!encoding} \\
-\livelink{chap:DWATdatalocation}{DW\_AT\_data\_location}&0x50&\livelink{chap:exprloc}{exprloc}
+\livelink{chap:DWATvtableelemlocation}{DW\_AT\_vtable\_elem\_location}&0x4d&\livelink{chap:classexprloc}{exprloc},
+ \livelink{chap:classloclistptr}{loclistptr} \addtoindexx{vtable element location attribute!encoding} \\
+\livelink{chap:DWATallocated}{DW\_AT\_allocated}&0x4e&\livelink{chap:classconstant}{constant}, \livelink{chap:classexprloc}{exprloc},
+ \livelink{chap:classreference}{reference} \addtoindexx{allocated attribute!encoding} \\
+\livelink{chap:DWATassociated}{DW\_AT\_associated}&0x4f&\livelink{chap:classconstant}{constant}, \livelink{chap:classexprloc}{exprloc},
+ \livelink{chap:classreference}{reference} \addtoindexx{associated attribute!encoding} \\
+\livelink{chap:DWATdatalocation}{DW\_AT\_data\_location}&0x50&\livelink{chap:classexprloc}{exprloc}
\addtoindexx{data location attribute!encoding} \\
-\livelink{chap:DWATbytestride}{DW\_AT\_byte\_stride}&0x51&constant, \livelink{chap:exprloc}{exprloc},
- reference \addtoindexx{byte stride attribute!encoding} \\
-\livelink{chap:DWATentrypc}{DW\_AT\_entry\_pc}&0x52&address
+\livelink{chap:DWATbytestride}{DW\_AT\_byte\_stride}&0x51&\livelink{chap:classconstant}{constant}, \livelink{chap:classexprloc}{exprloc},
+ \livelink{chap:classreference}{reference} \addtoindexx{byte stride attribute!encoding} \\
+\livelink{chap:DWATentrypc}{DW\_AT\_entry\_pc}&0x52&\livelink{chap:classaddress}{address}
\addtoindexx{entry pc attribute!encoding} \\
-\livelink{chap:DWATuseUTF8}{DW\_AT\_use\_UTF8}&0x53&\livelink{chap:flag}{flag}
+\livelink{chap:DWATuseUTF8}{DW\_AT\_use\_UTF8}&0x53&\livelink{chap:classflag}{flag}
\addtoindexx{use UTF8 attribute!encoding}\addtoindexx{UTF-8} \\
-\livelink{chap:DWATextension}{DW\_AT\_extension}&0x54&reference
+\livelink{chap:DWATextension}{DW\_AT\_extension}&0x54&\livelink{chap:classreference}{reference}
\addtoindexx{extension attribute!encoding} \\
-\livelink{chap:DWATranges}{DW\_AT\_ranges}&0x55&\livelink{chap:rangelistptr}{rangelistptr}
+\livelink{chap:DWATranges}{DW\_AT\_ranges}&0x55&\livelink{chap:classrangelistptr}{rangelistptr}
\addtoindexx{ranges attribute!encoding} \\
-\livelink{chap:DWATtrampoline}{DW\_AT\_trampoline}&0x56&address, \livelink{chap:flag}{flag},
- reference, string \addtoindexx{trampoline attribute!encoding} \\
-\livelink{chap:DWATcallcolumn}{DW\_AT\_call\_column}&0x57&constant
+\livelink{chap:DWATtrampoline}{DW\_AT\_trampoline}&0x56&\livelink{chap:classaddress}{address}, \livelink{chap:classflag}{flag},
+ \livelink{chap:classreference}{reference}, \livelink{chap:classstring}{string} \addtoindexx{trampoline attribute!encoding} \\
+\livelink{chap:DWATcallcolumn}{DW\_AT\_call\_column}&0x57&\livelink{chap:classconstant}{constant}
\addtoindexx{call column attribute!encoding} \\
-\livelink{chap:DWATcallfile}{DW\_AT\_call\_file}&0x58&constant
+\livelink{chap:DWATcallfile}{DW\_AT\_call\_file}&0x58&\livelink{chap:classconstant}{constant}
\addtoindexx{call file attribute!encoding} \\
-\livelink{chap:DWATcallline}{DW\_AT\_call\_line}&0x59&constant
+\livelink{chap:DWATcallline}{DW\_AT\_call\_line}&0x59&\livelink{chap:classconstant}{constant}
\addtoindexx{call line attribute!encoding} \\
-\livelink{chap:DWATdescription}{DW\_AT\_description}&0x5a&string
+\livelink{chap:DWATdescription}{DW\_AT\_description}&0x5a&\livelink{chap:classstring}{string}
\addtoindexx{description attribute!encoding} \\
-\livelink{chap:DWATbinaryscale}{DW\_AT\_binary\_scale}&0x5b&constant
+\livelink{chap:DWATbinaryscale}{DW\_AT\_binary\_scale}&0x5b&\livelink{chap:classconstant}{constant}
\addtoindexx{binary scale attribute!encoding} \\
-\livelink{chap:DWATdecimalscale}{DW\_AT\_decimal\_scale}&0x5c&constant
+\livelink{chap:DWATdecimalscale}{DW\_AT\_decimal\_scale}&0x5c&\livelink{chap:classconstant}{constant}
\addtoindexx{decimal scale attribute!encoding} \\
-\livelink{chap:DWATsmall}{DW\_AT\_small} &0x5d&reference
+\livelink{chap:DWATsmall}{DW\_AT\_small} &0x5d&\livelink{chap:classreference}{reference}
\addtoindexx{small attribute!encoding} \\
-\livelink{chap:DWATdecimalsign}{DW\_AT\_decimal\_sign}&0x5e&constant
+\livelink{chap:DWATdecimalsign}{DW\_AT\_decimal\_sign}&0x5e&\livelink{chap:classconstant}{constant}
\addtoindexx{decimal scale attribute!encoding} \\
-\livelink{chap:DWATdigitcount}{DW\_AT\_digit\_count}&0x5f&constant
+\livelink{chap:DWATdigitcount}{DW\_AT\_digit\_count}&0x5f&\livelink{chap:classconstant}{constant}
\addtoindexx{digit count attribute!encoding} \\
-\livelink{chap:DWATpicturestring}{DW\_AT\_picture\_string}&0x60&string
+\livelink{chap:DWATpicturestring}{DW\_AT\_picture\_string}&0x60&\livelink{chap:classstring}{string}
\addtoindexx{picture string attribute!encoding} \\
-\livelink{chap:DWATmutable}{DW\_AT\_mutable}&0x61&\livelink{chap:flag}{flag}
+\livelink{chap:DWATmutable}{DW\_AT\_mutable}&0x61&\livelink{chap:classflag}{flag}
\addtoindexx{mutable attribute!encoding} \\
-
-\livelink{chap:DWATthreadsscaled}{DW\_AT\_threads\_scaled}&0x62&\livelink{chap:flag}{flag}
+\livelink{chap:DWATthreadsscaled}{DW\_AT\_threads\_scaled}&0x62&\livelink{chap:classflag}{flag}
\addtoindexx{thread scaled attribute!encoding} \\
-\livelink{chap:DWATexplicit}{DW\_AT\_explicit}&0x63&\livelink{chap:flag}{flag}
+\livelink{chap:DWATexplicit}{DW\_AT\_explicit}&0x63&\livelink{chap:classflag}{flag}
\addtoindexx{explicit attribute!encoding} \\
-\livelink{chap:DWATobjectpointer}{DW\_AT\_object\_pointer}&0x64&reference
+\livelink{chap:DWATobjectpointer}{DW\_AT\_object\_pointer}&0x64&\livelink{chap:classreference}{reference}
\addtoindexx{object pointer attribute!encoding} \\
-\livelink{chap:DWATendianity}{DW\_AT\_endianity}&0x65&constant
+\livelink{chap:DWATendianity}{DW\_AT\_endianity}&0x65&\livelink{chap:classconstant}{constant}
\addtoindexx{endianity attribute!encoding} \\
-\livelink{chap:DWATelemental}{DW\_AT\_elemental}&0x66&\livelink{chap:flag}{flag}
+\livelink{chap:DWATelemental}{DW\_AT\_elemental}&0x66&\livelink{chap:classflag}{flag}
\addtoindexx{elemental attribute!encoding} \\
-\livelink{chap:DWATpure}{DW\_AT\_pure}&0x67&\livelink{chap:flag}{flag}
+\livelink{chap:DWATpure}{DW\_AT\_pure}&0x67&\livelink{chap:classflag}{flag}
\addtoindexx{pure attribute!encoding} \\
-\livelink{chap:DWATrecursive}{DW\_AT\_recursive}&0x68&\livelink{chap:flag}{flag}
+\livelink{chap:DWATrecursive}{DW\_AT\_recursive}&0x68&\livelink{chap:classflag}{flag}
\addtoindexx{recursive attribute!encoding} \\
-\livelink{chap:DWATsignature}{DW\_AT\_signature} \ddag &0x69&reference
+\livelink{chap:DWATsignature}{DW\_AT\_signature} \ddag &0x69&\livelink{chap:classreference}{reference}
\addtoindexx{signature attribute!encoding} \\
-\livelink{chap:DWATmainsubprogram}{DW\_AT\_main\_subprogram} \ddag &0x6a&\livelink{chap:flag}{flag}
+\livelink{chap:DWATmainsubprogram}{DW\_AT\_main\_subprogram} \ddag &0x6a&\livelink{chap:classflag}{flag}
\addtoindexx{main subprogram attribute!encoding} \\
-\livelink{chap:DWATdatabitoffset}{DW\_AT\_data\_bit\_offset} \ddag &0x6b&constant
+\livelink{chap:DWATdatabitoffset}{DW\_AT\_data\_bit\_offset} \ddag &0x6b&\livelink{chap:classconstant}{constant}
\addtoindexx{data bit offset attribute!encoding} \\
-\livelink{chap:DWATconstexpr}{DW\_AT\_const\_expr} \ddag &0x6c&\livelink{chap:flag}{flag}
+\livelink{chap:DWATconstexpr}{DW\_AT\_const\_expr} \ddag &0x6c&\livelink{chap:classflag}{flag}
\addtoindexx{constant expression attribute!encoding} \\
-\livelink{chap:DWATenumclass}{DW\_AT\_enum\_class} \ddag &0x6d&\livelink{chap:flag}{flag}
+\livelink{chap:DWATenumclass}{DW\_AT\_enum\_class} \ddag &0x6d&\livelink{chap:classflag}{flag}
\addtoindexx{enumeration class attribute!encoding} \\
-\livelink{chap:DWATlinkagename}{DW\_AT\_linkage\_name} \ddag &0x6e&string
+\livelink{chap:DWATlinkagename}{DW\_AT\_linkage\_name} \ddag &0x6e&\livelink{chap:classstring}{string}
\addtoindexx{linkage name attribute!encoding} \\
\livelink{chap:DWXXXlohiuser}{DW\_AT\_lo\_user}&0x2000 & --- \addtoindexx{low user attribute encoding} \\
\livelink{chap:DWXXXlohiuser}{DW\_AT\_hi\_user}&\xiiifff& --- \addtoindexx{high user attribute encoding} \\
\hline
\ddag \ \textit{New in \addtoindex{DWARF Version 4}}
\endlastfoot
-\livelink{chap:DWFORMaddr}{DW\_FORM\_addr}&0x01&address \\
-\livelink{chap:DWFORMblock2}{DW\_FORM\_block2}&0x03&\livelink{chap:block}{block} \\
-\livelink{chap:DWFORMblock4}{DW\_FORM\_block4}&0x04&\livelink{chap:block}{block} \\
-\livelink{chap:DWFORMdata2}{DW\_FORM\_data2}&0x05&constant \\
-\livelink{chap:DWFORMdata4}{DW\_FORM\_data4}&0x06&constant \\
-\livelink{chap:DWFORMdata8}{DW\_FORM\_data8}&0x07&constant \\
-\livelink{chap:DWFORMstring}{DW\_FORM\_string}&0x08&string \\
-\livelink{chap:DWFORMblock}{DW\_FORM\_block}&0x09&\livelink{chap:block}{block} \\
-\livelink{chap:DWFORMblock1}{DW\_FORM\_block1}&0x0a&\livelink{chap:block}{block} \\
-\livelink{chap:DWFORMdata1}{DW\_FORM\_data1}&0x0b&constant \\
-\livelink{chap:DWFORMflag}{DW\_FORM\_flag}&0x0c&\livelink{chap:flag}{flag} \\
-\livelink{chap:DWFORMsdata}{DW\_FORM\_sdata}&0x0d&constant \\
-\livelink{chap:DWFORMstrp}{DW\_FORM\_strp}&0x0e&string \\
-\livelink{chap:DWFORMudata}{DW\_FORM\_udata}&0x0f&constant \\
-\livelink{chap:DWFORMrefaddr}{DW\_FORM\_ref\_addr}&0x10&reference \\
-\livelink{chap:DWFORMref1}{DW\_FORM\_ref1}&0x11&reference \\
-\livelink{chap:DWFORMref2}{DW\_FORM\_ref2}&0x12&reference \\
-\livelink{chap:DWFORMref4}{DW\_FORM\_ref4}&0x13&reference \\
-\livelink{chap:DWFORMref8}{DW\_FORM\_ref8}&0x14&reference \\
-\livelink{chap:DWFORMrefudata}{DW\_FORM\_ref\_udata}&0x15&reference \\
+\livelink{chap:DWFORMaddr}{DW\_FORM\_addr}&0x01&\livelink{chap:classaddress}{address} \\
+\livelink{chap:DWFORMblock2}{DW\_FORM\_block2}&0x03&\livelink{chap:classblock}{block} \\
+\livelink{chap:DWFORMblock4}{DW\_FORM\_block4}&0x04&\livelink{chap:classblock}{block} \\
+\livelink{chap:DWFORMdata2}{DW\_FORM\_data2}&0x05&\livelink{chap:classconstant}{constant} \\
+\livelink{chap:DWFORMdata4}{DW\_FORM\_data4}&0x06&\livelink{chap:classconstant}{constant} \\
+\livelink{chap:DWFORMdata8}{DW\_FORM\_data8}&0x07&\livelink{chap:classconstant}{constant} \\
+\livelink{chap:DWFORMstring}{DW\_FORM\_string}&0x08&\livelink{chap:classstring}{string} \\
+\livelink{chap:DWFORMblock}{DW\_FORM\_block}&0x09&\livelink{chap:classblock}{block} \\
+\livelink{chap:DWFORMblock1}{DW\_FORM\_block1}&0x0a&\livelink{chap:classblock}{block} \\
+\livelink{chap:DWFORMdata1}{DW\_FORM\_data1}&0x0b&\livelink{chap:classconstant}{constant} \\
+\livelink{chap:DWFORMflag}{DW\_FORM\_flag}&0x0c&\livelink{chap:classflag}{flag} \\
+\livelink{chap:DWFORMsdata}{DW\_FORM\_sdata}&0x0d&\livelink{chap:classconstant}{constant} \\
+\livelink{chap:DWFORMstrp}{DW\_FORM\_strp}&0x0e&\livelink{chap:classstring}{string} \\
+\livelink{chap:DWFORMudata}{DW\_FORM\_udata}&0x0f&\livelink{chap:classconstant}{constant} \\
+\livelink{chap:DWFORMrefaddr}{DW\_FORM\_ref\_addr}&0x10&\livelink{chap:classreference}{reference} \\
+\livelink{chap:DWFORMref1}{DW\_FORM\_ref1}&0x11&\livelink{chap:classreference}{reference} \\
+\livelink{chap:DWFORMref2}{DW\_FORM\_ref2}&0x12&\livelink{chap:classreference}{reference} \\
+\livelink{chap:DWFORMref4}{DW\_FORM\_ref4}&0x13&\livelink{chap:classreference}{reference} \\
+\livelink{chap:DWFORMref8}{DW\_FORM\_ref8}&0x14&\livelink{chap:classreference}{reference} \\
+\livelink{chap:DWFORMrefudata}{DW\_FORM\_ref\_udata}&0x15&\livelink{chap:classreference}{reference} \\
\livelink{chap:DWFORMindirect}{DW\_FORM\_indirect}&0x16&(see Section \refersec{datarep:abbreviationstables}) \\
-\livelink{chap:DWFORMsecoffset}{DW\_FORM\_sec\_offset} \ddag &0x17&\livelink{chap:lineptr}{lineptr}, \livelink{chap:loclistptr}{loclistptr}, \livelink{chap:macptr}{macptr}, \livelink{chap:rangelistptr}{rangelistptr} \\
-\livelink{chap:DWFORMexprloc}{DW\_FORM\_exprloc} \ddag &0x18&\livelink{chap:exprloc}{exprloc} \\
-\livelink{chap:DWFORMflagpresent}{DW\_FORM\_flag\_present} \ddag &0x19&\livelink{chap:flag}{flag} \\
-\livelink{chap:DWFORMrefsig8}{DW\_FORM\_ref\_sig8} \ddag &0x20&reference \\
+\livelink{chap:DWFORMsecoffset}{DW\_FORM\_sec\_offset} \ddag &0x17&\livelink{chap:classlineptr}{lineptr}, \livelink{chap:classloclistptr}{loclistptr}, \livelink{chap:classmacptr}{macptr}, \livelink{chap:classrangelistptr}{rangelistptr} \\
+\livelink{chap:DWFORMexprloc}{DW\_FORM\_exprloc} \ddag &0x18&\livelink{chap:classexprloc}{exprloc} \\
+\livelink{chap:DWFORMflagpresent}{DW\_FORM\_flag\_present} \ddag &0x19&\livelink{chap:classflag}{flag} \\
+\livelink{chap:DWFORMrefsig8}{DW\_FORM\_ref\_sig8} \ddag &0x20&\livelink{chap:classreference}{reference} \\
\end{longtable}
\end{centering}
specifies the number of bytes in that block. The two offsets
are the same size as an address on the target machine.
+\needlines{5}
A base address selection entry and an
\addtoindexx{end of list entry!in location list}
end of list entry each
\end{longtable}
\end{centering}
-
+\needlines{4}
The encodings of the constants used in the
\livelink{chap:DWATdecimalsign}{DW\_AT\_decimal\_sign} attribute
are given in
\hline
\endlastfoot
-\livetarg{chap:DWDSClabel}{DW\_DSC\_label}&0x00 \\
-\livetarg{chap:DWDSCrange}{DW\_DSC\_range}&0x01 \\
+\livelink{chap:DWDSClabel}{DW\_DSC\_label}&0x00 \\
+\livelink{chap:DWDSCrange}{DW\_DSC\_range}&0x01 \\
\end{longtable}
\end{centering}
\begin{enumerate}[1. ]
\item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
-\addtoindexx{\texttt{unit\_length}}
+\addttindexx{unit\_length}
A 4\dash byte or 12\dash byte unsigned integer
\addtoindexx{initial length}
representing the length
% these tables.
\item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
-\addtoindexx{\texttt{unit\_length}}
+\addttindexx{unit\_length}
A 4-byte or 12-byte length containing the length of the
\addtoindexx{initial length}
set of entries for this compilation unit, not including the
%f
\item \dotdebuginfo{} \\
-An attribute value of class \livelink{chap:loclistptr}{loclistptr}
+An attribute value of class \livelink{chap:classloclistptr}{loclistptr}
(specifically form
\livelink{chap:DWFORMsecoffset}{DW\_FORM\_sec\_offset})
is an offset within the \dotdebugloc{}
%g
\item \dotdebuginfo{} \\
-An attribute value of class \livelink{chap:rangelistptr}{rangelistptr}
+An attribute value of class \livelink{chap:classrangelistptr}{rangelistptr}
(specifically form
\livelink{chap:DWFORMsecoffset}{DW\_FORM\_sec\_offset})
is an offset within the \dotdebugranges{} section of
%h
\item \dotdebuginfo{} \\
An attribute value of class
-\livelink{chap:macptr}{macptr} (specifically form
+\livelink{chap:classmacptr}{macptr} (specifically form
\livelink{chap:DWFORMsecoffset}{DW\_FORM\_sec\_offset}) is an
offset within the
\dotdebugmacinfo{} section
%i
\item \dotdebuginfo{} \\
An attribute value of class
-\livelink{chap:lineptr}{lineptr} (specifically form
+\livelink{chap:classlineptr}{lineptr} (specifically form
\livelink{chap:DWFORMsecoffset}{DW\_FORM\_sec\_offset})
is an offset in the
\dotdebugline{} section of the
% If draft is in the document class list, pix are just suggested
% by an outline, the pic does not appear as a picture.
%
-\newcommand{\docdate}{May 9, 2013 \hspace{1cm}(***\textbf{DRAFT}***)}
+\newcommand{\docdate}{May 10, 2013 \hspace{1cm}(***\textbf{DRAFT}***)}
%
\usepackage[T1]{fontenc}
\usepackage{palatino}
\newcommand{\nolink}[1]{#1}
\newcommand{\noindex}[1]{#1}
-% For index entries.
+% For index entries. The tt-variant of each pair is designed to
+% allow a word to appear in tt font in the main test and the index
+% but to collate in the index in its non-tt order. (LaTex normally
+% sorts all tt words before all non-tt words.)
\newcommand{\addtoindex}[1]{#1\index{#1}}
+\newcommand{\addttindex}[1]{\texttt{#1}\index{#1@\texttt{#1}}}
\newcommand{\addtoindexi}[2]{#1\index{#2}}
+\newcommand{\addttindexi}[2]{\texttt{#1}\index{#2@\texttt{#2}}}
\newcommand{\addtoindexx}[1]{\index{#1}}
+\newcommand{\addttindexx}[1]{\index{#1@\texttt{#1}}}
% Quote commands that avoid need for inline UTF-8 in these sources
\newcommand{\doublequote}[1]{\textquotedblleft #1\textquotedblright}
\livelink{chap:DWTAGvariant}{DW\_TAG\_variant},
\livelink{chap:DWTAGvariantpart}{DW\_TAG\_variant\_part},
\livelink{chap:DWTAGvolatiletype}{DW\_TAG\_volatile\_type},
-\livelink{chap:DWTAGwithstmt}{DW\_TAG\_with\_stmt},
+\livelink{chap:DWTAGwithstmt}{DW\_TAG\_with\_stmt}
}
\simplerule[6in]
\end{table}
contexts where they may be appropriate.
Examples include
\livelink{chap:DWATartificial}{DW\_AT\_artificial},
-the \livelink{chap:DWATdeclfilefilecontainingsourcedeclaration}{declaration coordinates}, and
+the \livelink{chap:declarationcoordinates}{declaration coordinates}, and
\livelink{chap:DWATdescription}{DW\_AT\_description},
among others.}
&\livelinki{chap:DWATvtableelemlocationvirtualfunctiontablevtableslot}{Virtual function vtable slot}{virtual function vtable slot}\\
\end{longtable}
+\addtoindexx{address|see {\textit{also} address class}}
+\addtoindexx{block|see {\textit{also} block class}}
+\addtoindexx{constant|see {\textit{also} constant class}}
+\addtoindexx{exprloc|see {\textit{also} exprloc class}}
+\addtoindexx{flag|see {\textit{also} flag class}}
+\addtoindexx{lineptr|see {\textit{also} lineptr class}}
+\addtoindexx{loclistptr|see {\textit{also} loclistptr class}}
+\addtoindexx{macptr|see {\textit{also} macptr class}}
+\addtoindexx{rangelistptr|see {\textit{also} rangelistptr class}}
+\addtoindexx{reference|see {\textit{also} reference class}}
+\addtoindexx{string|see {\textit{also} string class}}
+\addtoindexx{class of attribute value!address|see {address class}}
+\addtoindexx{class of attribute value!block|see {block class}}
+\addtoindexx{class of attribute value!constant|see {constant class}}
+\addtoindexx{class of attribute value!exprloc|see {exprloc class}}
+\addtoindexx{class of attribute value!flag|see {flag class}}
+\addtoindexx{class of attribute value!lineptr|see {lineptr class}}
+\addtoindexx{class of attribute value!loclistptr|see {loclistptr class}}
+\addtoindexx{class of attribute value!macptr|see {macptr class}}
+\addtoindexx{class of attribute value!rangelistptr|see {rangelistptr class}}
+\addtoindexx{class of attribute value!reference|see {reference class}}
+\addtoindexx{class of attribute value!string|see {string class}}
+
\begin{table}[here]
-\caption{Classes of Attribute value}
+\caption{Classes of attribute value}
\label{tab:classesofattributevalue}
\centering
-% Attribute Class entries need a ref to definition point.
\setlength{\extrarowheight}{0.1cm}
\begin{tabular}{l|p{11cm}} \hline
Attribute Class & General Use and Encoding \\ \hline
-\livetargi{chap:address}{address}{address class}
+\hypertarget{chap:classaddress}{}
+\livelinki{datarep:classaddress}{address}{address class}
&Refers to some location in the address space of the described program.
- \\
-\livetargi{chap:block}{block}{block class}
+\\
+
+\hypertarget{chap:classblock}{}
+\livelinki{datarep:classblock}{block}{block class}
& An arbitrary number of uninterpreted bytes of data.
- \\
-\livetargi{chap:constant}{constant}{constant class}
+\\
+
+\hypertarget{chap:classconstant}{}
+\livelinki{datarep:classconstant}{constant}{constant class}
&One, two, four or eight bytes of uninterpreted data, or data
encoded in the variable length format known as LEB128
(see Section \refersec{datarep:variablelengthdata}).
\textit{Most constant values are integers of one kind or
another (codes, offsets, counts, and so on); these are
-sometimes called ``integer constants'' for emphasis.}
+sometimes called \doublequote{integer constants} for emphasis.}
\addtoindexx{integer constant}
-\addtoindexx{constant class!integer} \\
+\addtoindexx{constant class!integer}
+\\
-\livetargi{chap:exprloc}{exprloc}{exprloc class}
+\hypertarget{chap:classexprloc}{}
+\livelinki{datarep:classexprloc}{exprloc}{exprloc class}
&A DWARF expression or location description.
\\
-\livetargi{chap:flag}{flag}{flag class}
+
+\hypertarget{chap:classflag}{}
+\livelinki{datarep:classflag}{flag}{flag class}
&A small constant that indicates the presence or absence of an attribute.
\\
-\livetargi{chap:lineptr}{lineptr}{lineptr class}
+
+\hypertarget{chap:classlineptr}{}
+\livelinki{datarep:classlineptr}{lineptr}{lineptr class}
&Refers to a location in the DWARF section that holds line number information.
\\
-\livetargi{chap:loclistptr}{loclistptr}{loclistptr class}
+
+\hypertarget{chap:classloclistptr}{}
+\livelinki{datarep:classloclistptr}{loclistptr}{loclistptr class}
&Refers to a location in the DWARF section that holds location lists, which
describe objects whose location can change during their lifetime.
\\
-\livetargi{chap:macptr}{macptr}{macptr class}
+
+\hypertarget{chap:classmacptr}{}
+\livelinki{datarep:classmacptr}{macptr}{macptr class}
& Refers to a location in the DWARF section that holds macro definition
- information. \\
-\livetargi{chap:rangelistptr}{rangelistptr}{rangelistptr class}
-& Refers to a location in the DWARF section that holds non\dash contiguous address ranges. \\
+ information.
+\\
-\livetargi{chap:reference}{reference}{reference class}
+\hypertarget{chap:classrangelistptr}{}
+\livelinki{datarep:classrangelistptr}{rangelistptr}{rangelistptr class}
+& Refers to a location in the DWARF section that holds non\dash contiguous address ranges.
+\\
+
+\hypertarget{chap:classreference}{}
+\livelinki{datarep:classreference}{reference}{reference class}
& Refers to one of the debugging information
entries that describe the program. There are three types of
reference. The first is an offset relative to the beginning
is an indirect reference to a
\addtoindexx{type signature}
type definition using a 64\dash bit signature
-for that type. \\
+for that type.
+\\
-\livetargi{chap:string}{string}{string class}
+\hypertarget{chap:classstring}{}
+\livelinki{datarep:classstring}{string}{string class}
& A null\dash terminated sequence of zero or more
(non\dash null) bytes. Data in this class are generally
printable strings. Strings may be represented directly in
the debugging information entry or as an offset in a separate
-string table. \\
+string table.
+\\
\hline
\end{tabular}
\end{table}
from 0 through 31, inclusive.
\itembfnl{\livetarg{chap:DWOPaddr}{DW\_OP\_addr}}
-The \livelink{chap:DWOPaddr}{DW\_OP\_addr} operation has a single operand that encodes
+The \livetarg{chap:DWOPaddr}{DW\_OP\_addr} operation has a single operand that encodes
a machine address and whose size is the \addtoindex{size of an address}
on the target machine.
manner. As the value of an attribute, a location description
is encoded using
\addtoindexx{exprloc class}
-class \livelink{chap:exprloc}{exprloc}
+class \livelink{chap:classexprloc}{exprloc}
and a location list is encoded
-using class \livelink{chap:loclistptr}{loclistptr}
+using class \livelink{chap:classloclistptr}{loclistptr}
(which
\addtoindex{loclistptr}
serves as an offset into a
object in question is defined, it is assumed that the object is
not available for the portion of the range that is not covered.
+\needlines{5}
A base
\addtoindexi{address}{address selection|see{base address selection}}
selection
%FIXME: The word 'this' should be rendered like a variant italic,
%FIXME: not as a quoted name. Changed to tt font--RB
entry to represent the
-\addtoindexx{\texttt{this} parameter}
+\texttt{this} parameter\index{this parameter@\texttt{this} parameter}
hidden \texttt{this} parameter that most C++
implementations pass as the first argument to non-static member
functions.}
\hypertarget{chap:DWATartificialobjectsortypesthat}
may have a
\livelink{chap:DWATartificial}{DW\_AT\_artificial} attribute,
-which is a \livelink{chap:flag}{flag}.
+which is a \livelink{chap:classflag}{flag}.
\section{Segmented Addresses}
\label{chap:segmentedaddresses}
a
\livelink{chap:DWATdeclaration}{DW\_AT\_declaration}
attribute, which is a
-\livelink{chap:flag}{flag}.
+\livelink{chap:classflag}{flag}.
\subsection{Declarations Completing Non-Defining Declarations}
A debugging information entry that represents a
declaration that completes another (earlier)
non\dash defining declaration may have a
\livelink{chap:DWATspecification}{DW\_AT\_specification}
-attribute whose value is a reference to
+attribute whose value is a \livelink{chap:classreference}{reference} to
the debugging information entry representing the non-defining declaration. A debugging
information entry with a
\livelink{chap:DWATspecification}{DW\_AT\_specification}
\section{Declaration Coordinates}
\label{chap:declarationcoordinates}
-\textit{It is
-\addtoindexx{declaration coordinates}
-sometimes useful in a debugger to be able to associate
+\livetargi{chap:declarationcoordinates}{}{declaration coordinates}
+\textit{It is sometimes useful in a debugger to be able to associate
a declaration with its occurrence in the program source.}
Any debugging information
\livelink{chap:DWATdeclfile}{DW\_AT\_decl\_file},
\livelink{chap:DWATdeclline}{DW\_AT\_decl\_line} and
\livelink{chap:DWATdeclcolumn}{DW\_AT\_decl\_column}
-attributes each of whose value is an unsigned integer constant.
+attributes each of whose value is an unsigned
+\livelink{chap:classconstant}{integer constant}.
The value of
-\addtoindex{declaration file attribute}
+\addtoindexx{declaration file attribute}
the
\livelink{chap:DWATdeclfile}{DW\_AT\_decl\_file}
attribute
has been specified.
The value of
-\addtoindex{declaration line attribute}
+\addtoindexx{declaration line attribute}
the \livelink{chap:DWATdeclline}{DW\_AT\_decl\_line} attribute represents
the source line number at which the first character of
the identifier of the declared object appears. The value 0
indicates that no source line has been specified.
The value of
-\addtoindex{declaration column attribute}
+\addtoindexx{declaration column attribute}
the \livelink{chap:DWATdeclcolumn}{DW\_AT\_decl\_column} attribute represents
the source column number at which the first character of
the identifier of the declared object appears. The value 0
\livelink{chap:DWATname}{DW\_AT\_name} attribute,
whose
\addtoindexx{name attribute}
-value is a string representing the name as it appears in
+value is a \livelink{chap:classstring}{string}
+representing 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
DWARF expression operator
(see Section \refersec{chap:controlflowoperations}).
+\needlines{5}
\section{Code Addresses and Ranges}
\label{chap:codeaddressesandranges}
Any debugging information entry describing an entity that has
cannot be described as a single contiguous range, the entry has
a \livelink{chap:DWATranges}{DW\_AT\_ranges} attribute
\addtoindexx{ranges attribute}
-whose value is of class \livelink{chap:rangelistptr}{rangelistptr}
+whose value is of class \livelink{chap:classrangelistptr}{rangelistptr}
and indicates the beginning of a \addtoindex{range list}.
Similarly,
a \livelink{chap:DWATstartscope}{DW\_AT\_start\_scope} attribute
\addtoindexx{start scope attribute}
may have a value of class
-\livelink{chap:rangelistptr}{rangelistptr} for the same reason.
+\livelink{chap:classrangelistptr}{rangelistptr} for the same reason.
Range lists are contained
in a separate object file section called
There is no requirement that
the entries be ordered in any particular way.
+\needlines{5}
A base address selection entry consists of:
\begin{enumerate}[1. ]
\item The value of the largest representable address offset (for example, \wffffffff when the size of
The value of these
attributes is determined based on the class as follows:
\begin{itemize}
-\item For a \livelink{chap:constant}{constant}, the value of the constant is the value of
+\item For a \livelink{chap:classconstant}{constant}, the value of the constant is the value of
the attribute.
-\item For a \livelink{chap:reference}{reference}, the
-value is a reference to another
+\item For a \livelink{chap:classreference}{reference}, the
+value is a \livelink{chap:classreference}{reference} to another
entity which specifies the value of the attribute.
-\item For an \livelink{chap:exprloc}{exprloc}, the value is interpreted as a
+\item For an \livelink{chap:classexprloc}{exprloc}, the value is interpreted as a
DWARF expression;
evaluation of the expression yields the value of
the attribute.
\label{chap:byteandbitsizes}
% Some trouble here with hbox full, so we try optional word breaks.
Many debugging information entries allow either a
-\livelink{chap:DWATbytesize}{DW\_AT\_byte\_size} attribute or a \livelink{chap:DWATbitsize}{DW\_AT\_bit\_size} attribute,
-whose integer constant value
+\livelink{chap:DWATbytesize}{DW\_AT\_byte\_size} attribute or a
+\livelink{chap:DWATbitsize}{DW\_AT\_bit\_size} attribute,
+whose \livelink{chap:classconstant}{integer constant} value
(see Section \refersec{chap:staticanddynamicvaluesofattributes})
specifies an
amount of storage. The value of the \livelink{chap:DWATbytesize}{DW\_AT\_byte\_size} attribute
is interpreted in bytes and the value of the \livelink{chap:DWATbitsize}{DW\_AT\_bit\_size}
attribute is interpreted in bits.
-Similarly, the integer
-constant value of a \livelink{chap:DWATbytestride}{DW\_AT\_byte\_stride} attribute is interpreted
-in bytes and the integer constant value of a \livelink{chap:DWATbitstride}{DW\_AT\_bit\_stride}
+Similarly, the \livelink{chap:classconstant}{integer constant}
+value of a \livelink{chap:DWATbytestride}{DW\_AT\_byte\_stride} attribute is interpreted
+in bytes and the \livelink{chap:classconstant}{integer constant} value of a
+\livelink{chap:DWATbitstride}{DW\_AT\_bit\_stride}
attribute is interpreted in bits.
\section{Linkage Names}
Each set begins with a header containing five values:
\begin{enumerate}[1. ]
\item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
-\addtoindexx{\texttt{unit\_length}}
+\addttindexx{unit\_length}
The total length of all of the
entries for that set, not including the length field itself
(see Section \refersec{datarep:initiallengthvalues}).
The program\dash counter value corresponding to a machine instruction
generated by the compiler. \\
-\addtoindex{\texttt{op\_index}} &
+\addttindex{op\_index} &
An unsigned integer representing the index of an operation within a VLIW
instruction. The index of the first operation is 0. For non\dash VLIW
architectures, this register will always be 0.
-The \texttt{address} and \addtoindex{\texttt{op\_index}} registers,
+The \texttt{address} and \addttindex{op\_index} registers,
taken together, form an operation
pointer that can reference any individual operation within the instruction
stream. \\
-\addtoindex{\texttt{file}} &
+\addttindex{file} &
An unsigned integer indicating the identity of the source file
corresponding to a machine instruction. \\
-\addtoindex{\texttt{line}} &
+\addttindex{line} &
An unsigned integer indicating a source line number. Lines are numbered
beginning at 1. The compiler may emit the value 0 in cases where an
instruction cannot be attributed to any source line. \\
-\addtoindex{\texttt{column}} &
+\addttindex{column} &
An unsigned integer indicating a column number within a source line.
Columns are numbered beginning at 1. The value 0 is reserved to indicate
that a statement begins at the ``left edge'' of the line. \\
-\addtoindex{\texttt{is\_stmt}} &
+\addttindex{is\_stmt} &
A boolean indicating that the current instruction is a recommended
breakpoint location. A recommended breakpoint location
is intended to \doublequote{represent} a line, a
statement and/or a semantically distinct subpart of a
statement. \\
-\addtoindex{\texttt{basic\_block}} &
+\addttindex{basic\_block} &
A boolean indicating that the current instruction is the beginning of a
\addtoindex{basic block}. \\
-\addtoindex{\texttt{end\_sequence}} &
+\addttindex{end\_sequence} &
A boolean indicating that the current address is that of the first byte after
the end of a sequence of target machine instructions.
-\addtoindex{\texttt{end\_sequence}}
+\addttindex{end\_sequence}
terminates a sequence of lines; therefore other information in the same
row is not meaningful. \\
-\addtoindex{\texttt{prologue\_end}} &
+\addttindex{prologue\_end} &
A boolean indicating that the current address is one (of possibly many)
where execution should be suspended for an entry breakpoint of a
function. \\
-\addtoindex{\texttt{epilogue\_begin}} &
+\addttindex{epilogue\_begin} &
A boolean indicating that the current address is one (of possibly many)
where execution should be suspended for an exit breakpoint of a function. \\
-\addtoindex{\texttt{isa}} &
+\addttindex{isa} &
An unsigned integer whose value encodes the applicable
instruction set architecture for the current instruction.
encoding be defined by the ABI authoring committee for each
architecture.} \\
-\addtoindex{\texttt{discriminator}} &
+\addttindex{discriminator} &
An unsigned integer identifying the block to which the
current instruction belongs. Discriminator values are assigned
arbitrarily by the DWARF producer and serve to distinguish
\begin{center}
\begin{tabular}{lp{9.5cm}}
\texttt{address} & 0 \\
-\addtoindex{\texttt{op\_index}} & 0 \\
+\addttindex{op\_index} & 0 \\
\texttt{file} & 1 \\
\texttt{line} & 1 \\
\texttt{column} & 0 \\
-\addtoindex{\texttt{is\_stmt}} & determined by \addtoindex{\texttt{default\_is\_stmt}}
+\addttindex{is\_stmt} & determined by \addttindex{default\_is\_stmt}
in the line number program header \\
-\addtoindex{\texttt{basic\_block}} & \doublequote{false} \addtoindexx{basic block} \\
-\addtoindex{\texttt{end\_sequence}} & \doublequote{false} \\
-\addtoindex{\texttt{prologue\_end}} & \doublequote{false} \\
-\addtoindex{\texttt{epilogue\_begin}} & \doublequote{false} \\
-\addtoindex{\texttt{isa}} & 0 \\
-\addtoindex{\texttt{discriminator}} & 0 \\
+\addttindex{basic\_block} & \doublequote{false} \addtoindexx{basic block} \\
+\addttindex{end\_sequence} & \doublequote{false} \\
+\addttindex{prologue\_end} & \doublequote{false} \\
+\addttindex{epilogue\_begin} & \doublequote{false} \\
+\addttindex{isa} & 0 \\
+\addttindex{discriminator} & 0 \\
\end{tabular}
\end{center}
\textit{The
-\addtoindex{\texttt{isa}} value 0 specifies that the instruction set is the
+\addttindex{isa} value 0 specifies that the instruction set is the
architecturally determined default instruction set. This may
be fixed by the ABI, or it may be specified by other means,
for example, by the object file description.}
\begin{enumerate}[1. ]
\item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
-\addtoindexx{\texttt{unit\_length}}
+\addttindexx{unit\_length}
The size in bytes of the line number information for this
compilation unit, not including the length field itself
(see Section \refersec{datarep:initiallengthvalues}).
version number.
\item \texttt{header\_length} \\
-The number of bytes following the \addtoindex{\texttt{header\_length}} field to the
+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
length; in the \sixtyfourbitdwarfformat, this field is an
(see Section \refersec{datarep:32bitand64bitdwarfformats}).
\item \texttt{minimum\_instruction\_length} (\addtoindex{ubyte}) \\
-\addtoindexx{\texttt{minimum\_instruction\_length}}
+\addttindexx{minimum\_instruction\_length}
The size in bytes of the smallest target machine
instruction. Line number program opcodes that alter
-the \texttt{address} and \addtoindex{\texttt{op\_index}}
+the \texttt{address} and \addttindex{op\_index}
registers use this and
-\addtoindex{\texttt{maximum\_operations\_per\_instruction}}
+\addttindex{maximum\_operations\_per\_instruction}
(see following) in their calculations.
\needlines{9}
\item \texttt{maximum\_operations\_per\_instruction} (\addtoindex{ubyte}) \\
The
-\addtoindexx{\texttt{maximum\_operations\_per\_instruction}}
+\addttindexx{maximum\_operations\_per\_instruction}
maximum number of individual operations that may be
encoded in an instruction. Line number program opcodes
that alter the \texttt{address} and
-\addtoindex{\texttt{op\_index}} registers use this and
-\addtoindex{\texttt{minimum\_instruction\_length}} (see preceeding)
+\addttindex{op\_index} registers use this and
+\addttindex{minimum\_instruction\_length} (see preceeding)
in their calculations.
For non-VLIW
-architectures, this field is 1, the \addtoindex{\texttt{op\_index}} register is always
+architectures, this field is 1, the \addttindex{op\_index} register is always
0, and the operation pointer is simply the \texttt{address} register.
\needlines{4}
\item \texttt{default\_is\_stmt} (\addtoindex{ubyte}) \\
-\addtoindexx{\texttt{default\_is\_stmt}}
-The initial value of the \addtoindex{\texttt{is\_stmt}} register.
+\addttindexx{default\_is\_stmt}
+The initial value of the \addttindex{is\_stmt} register.
\textit{A simple approach
to building line number information when machine instructions
are emitted in an order corresponding to the source program
-is to set \addtoindex{\texttt{default\_is\_stmt}}
+is to set \addttindex{default\_is\_stmt}
to ``true'' and to not change the
-value of the \addtoindex{\texttt{is\_stmt}} register
+value of the \addttindex{is\_stmt} register
within the line number program.
One matrix entry is produced for each line that has code
generated for it. The effect is that every entry in the
breakpoint location for the line number. \livelink{chap:DWLNSnegatestmt}{DW\_LNS\_negate\_stmt}
opcodes in the line number program control which matrix entries
constitute such a recommendation and
-\addtoindex{\texttt{default\_is\_stmt}} might
+\addttindex{default\_is\_stmt} might
be either ``true'' or ``false''. This approach might be
used as part of support for debugging optimized code.}
\item \texttt{line\_base} (\addtoindex{sbyte}) \\
-\addtoindexx{\texttt{line\_base}}
+\addttindexx{line\_base}
This parameter affects the meaning of the special opcodes. See below.
\item \texttt{line\_range} (\addtoindex{ubyte}) \\
-\addtoindexx{\texttt{line\_range}}
+\addttindexx{line\_range}
This parameter affects the meaning of the special opcodes. See below.
\item \texttt{opcode\_base} (\addtoindex{ubyte}) \\
The
-\addtoindexx{\texttt{opcode\_base}}
+\addttindexx{opcode\_base}
number assigned to the first special opcode.
\textit{Opcode base is typically one greater than the highest-numbered
-\addtoindexx{\texttt{opcode\_base}}
+\addttindexx{opcode\_base}
standard opcode defined for the specified version of the line
number information (12 in
\addtoindex{DWARF Version 3} and
\addtoindexx{DWARF Version 2}
Version 2).
If opcode\_base is less than the typical value,
-\addtoindexx{\texttt{opcode\_base}}
+\addttindexx{opcode\_base}
then standard opcode numbers greater than or equal to the
opcode base are not used in the line number table of this unit
(and the codes are treated as special opcodes). If \texttt{opcode\_base}
opcode (not inclusive) are used for vendor specific extensions.}
\item \texttt{standard\_opcode\_lengths} (array of \addtoindex{ubyte}) \\
-\addtoindexx{\texttt{standard\_opcode\_lengths}}
+\addttindexx{standard\_opcode\_lengths}
This array specifies the number of \addtoindex{LEB128} operands for each
of the standard opcodes. The first element of the array
corresponds to the opcode whose value is 1, and the last
is \texttt{opcode\_base - 1}.
\textit{By increasing \texttt{opcode\_base}, and adding elements to this array,
-\addtoindexx{\texttt{opcode\_base}}
+\addttindexx{opcode\_base}
new standard opcodes can be added, while allowing consumers who
do not know about these new opcodes to be able to skip them.}
\needlines{3}
\item \texttt{include\_directories} (sequence of path names) \\
Entries
-\addtoindexx{\texttt{include\_directories}}
+\addttindexx{include\_directories}
in this sequence describe each path that was searched
for included source files in this compilation. (The paths
include those directories specified explicitly by the user for
Entries
\addtoindexx{file names}
in
-\addtoindexx{\texttt{file\_names}}
+\addttindexx{file\_names}
this sequence describe source files that contribute
to the line number information for this compilation unit or is
-used in other contexts, such as in a declaration coordinate or
+used in other contexts, such as in a
+\livelinki{chap:declarationcoordinates}{declaration coordinate}{declaration coordinates} or
a macro file inclusion. Each entry consists of the following
values:
\livelink{chap:DWATcompdir}{DW\_AT\_comp\_dir}
attribute given in the compilation unit) or one
of the directories listed in the
-\addtoindex{\texttt{include\_directories}} section.
+\addttindex{include\_directories} section.
\item An unsigned LEB128\addtoindexx{LEB128!unsigned}
number representing the directory
index of a directory in the
-\addtoindex{\texttt{include\_directories}} section.
+\addttindex{include\_directories} section.
\item An unsigned LEB128\addtoindexx{LEB128!unsigned}
The last entry is followed by a single null byte.
The directory index represents an entry in the
-\addtoindex{\texttt{include\_directories}} section.
+\addttindex{include\_directories} section.
The index is 0 if the file was
found in the current directory of the compilation, 1 if it
was found in the first directory in the
-\addtoindex{\texttt{include\_directories}}
+\addttindex{include\_directories}
section, and so on. The directory index is ignored for file
names that represent full path names.
\item Add a signed integer to the \texttt{line} register.
\item Modify the \addtoindex{operation pointer} by incrementing the
-\texttt{address} and \addtoindex{\texttt{op\_index|}} registers as described below.
+\texttt{address} and \addttindex{op\_index} registers as described below.
\item Append a row to the matrix using the current values
of the state machine registers.
-\item Set the \addtoindex{\texttt{basic\_block}} register to \doublequote{false.} \addtoindexx{basic block}
-\item Set the \addtoindex{\texttt{prologue\_end}} register to \doublequote{false.}
-\item Set the \addtoindex{\texttt{epilogue\_begin}} register to \doublequote{false.}
-\item Set the \addtoindex{\texttt{discriminator}} register to 0.
+\item Set the \addttindex{basic\_block} register to \doublequote{false.} \addtoindexx{basic block}
+\item Set the \addttindex{prologue\_end} register to \doublequote{false.}
+\item Set the \addttindex{epilogue\_begin} register to \doublequote{false.}
+\item Set the \addttindex{discriminator} register to 0.
\end{enumerate}
All of the special opcodes do those same seven things; they
differ from one another only in what values they add to the
-\texttt{line}, \texttt{address} and \addtoindex{\texttt{op\_index}} registers.
+\texttt{line}, \texttt{address} and \addttindex{op\_index} registers.
\textit{Instead of assigning a fixed meaning to each special opcode,
to add larger positive values to the \texttt{address} register. To
permit this variety of strategies, the line number program
header defines a
-\addtoindex{\texttt{line\_base}}
+\addttindex{line\_base}
field that specifies the minimum
value which a special opcode can add to the line register
and a
-\addtoindex{\texttt{line\_range}}
+\addttindex{line\_range}
field that defines the range of values it
can add to the line register.}
A special opcode value is chosen based on the amount that needs
-to be added to the \texttt{line}, \texttt{address} and \addtoindex{\texttt{op\_index}} registers.
+to be added to the \texttt{line}, \texttt{address} and \addttindex{op\_index} registers.
The maximum line increment for a special opcode is the value
of the
-\addtoindex{\texttt{line\_base}}
+\addttindex{line\_base}
field in the header, plus the value of the
-\addtoindex{\texttt{line\_range}} field, minus 1 (line base +
+\addttindex{line\_range} field, minus 1 (line base +
line range - 1).
If the desired line increment is greater than the maximum
line increment, a standard opcode must be used instead of a
The special opcode is then calculated using the following formula:
\begin{alltt}
opcode =
- (\textit{desired line increment} - \addtoindex{line\_base}) +
- (\addtoindex{line\_range} * \textit{operation advance}) + \addtoindex{opcode\_base}
+ (\textit{desired line increment} - \addttindex{line\_base}) +
+ (\addttindex{line\_range} * \textit{operation advance}) + \addttindex{opcode\_base}
\end{alltt}
If the resulting opcode is greater than 255, a standard opcode
must be used instead.
-\textit{When \addtoindex{\texttt{maximum\_operations\_per\_instruction}} is 1,
+\textit{When \addttindex{maximum\_operations\_per\_instruction} is 1,
the operation advance is simply the address increment divided by the
-\addtoindex{\texttt{minimum\_instruction\_length}}.}
+\addttindex{minimum\_instruction\_length}.}
\needlines{6}
-To decode a special opcode, subtract the \addtoindex{\texttt{opcode\_base}} from
+To decode a special opcode, subtract the \addttindex{opcode\_base} from
the opcode itself to give the \textit{adjusted opcode}.
The \textit{operation advance}
is the result of the adjusted opcode divided by the
\texttt{line\_range}. The new \texttt{address} and
-\addtoindex{\texttt{op\_index}} values are given by
+\addttindex{op\_index} values are given by
\begin{alltt}
\textit{adjusted opcode} = opcode \dash opcode\_base
\textit{operation advance} = \textit{adjusted opcode} / line\_range
new address = address +
- \addtoindex{minimum\_instruction\_length} *
- ((\addtoindex{op\_index} + \addtoindex{operation advance}) / \addtoindex{maximum\_operations\_per\_instruction})
+ \addttindex{minimum\_instruction\_length} *
+ ((\addttindex{op\_index} + \addtoindex{operation advance}) / \addttindex{maximum\_operations\_per\_instruction})
new op\_index =
- (\addtoindex{op\_index} + \addtoindex{operation advance}) \% \addtoindex{maximum\_operations\_per\_instruction}
+ (\addttindex{op\_index} + \addtoindex{operation advance}) \% \addttindex{maximum\_operations\_per\_instruction}
\end{alltt}
-\textit{When the \addtoindex{\texttt{maximum\_operations\_per\_instruction}} field is 1,
+\textit{When the \addttindex{maximum\_operations\_per\_instruction} field is 1,
\texttt{op\_index} is always 0 and these calculations simplify to those
given for addresses in
\addtoindex{DWARF Version 3}.}
The amount to increment the line register is the
-\addtoindex{\texttt{line\_base}} plus
+\addttindex{line\_base} plus
the result of the
\textit{\addtoindex{adjusted opcode}} modulo the
-\addtoindex{\texttt{line\_range}}. That
+\addttindex{line\_range}. That
is,
\begin{alltt}
- line increment = \addtoindex{line\_base} + (\textit{adjusted opcode} \% \addtoindex{line\_range})
+ line increment = \addttindex{line\_base} + (\textit{adjusted opcode} \% \addttindex{line\_range})
\end{alltt}
\textit{As an example, suppose that the opcode\_base is 13,
-\addtoindex{\texttt{line\_base}} is -3,
-\addtoindex{\texttt{line\_range}} is 12,
-\addtoindex{\texttt{minimum\_instruction\_length}} is 1
+\addttindex{line\_base} is -3,
+\addttindex{line\_range} is 12,
+\addttindex{minimum\_instruction\_length} is 1
and
-\addtoindex{\texttt{maximum\_operations\_per\_instruction}} is 1.
+\addttindex{maximum\_operations\_per\_instruction} is 1.
This means that
we can use a special opcode whenever two successive rows in
the matrix have source line numbers differing by any value
\end{figure}
\textit{There is no requirement that the expression
-255 - \addtoindex{\texttt{line\_base}} + 1 be an integral multiple of
-\addtoindex{\texttt{line\_range}}. }
+255 - \addttindex{line\_base} + 1 be an integral multiple of
+\addttindex{line\_range}. }
\subsubsection{Standard Opcodes}
\label{chap:standardopcodes}
The \livetarg{chap:DWLNScopy}{DW\_LNS\_copy}
opcode takes no operands. It appends a row
to the matrix using the current values of the state machine
-registers. Then it sets the \addtoindex{\texttt{discriminator}} register to 0,
-and sets the \addtoindex{\texttt{basic\_block}},
-\addtoindex{\texttt{prologue\_end}} and
-\addtoindex{\texttt{epilogue\_begin}}
+registers. Then it sets the \addttindex{discriminator} register to 0,
+and sets the \addttindex{basic\_block},
+\addttindex{prologue\_end} and
+\addttindex{epilogue\_begin}
registers to ``false.''
\item \textbf{DW\_LNS\_advance\_pc} \\
The \livetarg{chap:DWLNSadvancepc}{DW\_LNS\_advance\_pc}
opcode takes a single unsigned LEB128\addtoindexx{LEB128!unsigned}
operand as the \addtoindex{operation advance} and modifies the \texttt{address}
-and \addtoindex{\texttt{op\_index}} registers as specified in
+and \addttindex{op\_index} registers as specified in
Section \refersec{chap:specialopcodes}.
\item \textbf{DW\_LNS\_advance\_line} \\
\needlines{4}
\item \textbf{DW\_LNS\_negate\_stmt} \\
The \livetarg{chap:DWLNSnegatestmt}{DW\_LNS\_negate\_stmt} opcode takes no
-operands. It sets the \addtoindex{\texttt{is\_stmt}} register of the state machine
+operands. It sets the \addttindex{is\_stmt} register of the state machine
to the logical negation of its current value.
\needlines{4}
opcode
\addtoindexx{basic block}
takes no operands.
-It sets the \texttt{basic\_block} register of the
+It sets the \addttindex{basic\_block} register of the
state machine to ``true.''
\item \textbf{DW\_LNS\_const\_add\_pc} \\
The \livetarg{chap:DWLNSconstaddpc}{DW\_LNS\_const\_add\_pc} opcode takes
-no operands. It advances the \texttt{address} and \texttt{op\_index} registers
+no operands. It advances the \texttt{address} and \addttindex{op\_index} registers
by the increments corresponding to special opcode 255.
\textit{When the line number program needs to advance the \texttt{address}
\item \textbf{DW\_LNS\_fixed\_advance\_pc} \\
The \livetarg{chap:DWLNSfixedadvancepc}{DW\_LNS\_fixed\_advance\_pc} opcode
takes a single \addtoindex{uhalf} (unencoded) operand and adds it to the
-\texttt{address} register of the state machine and sets the \texttt{op\_index}
+\texttt{address} register of the state machine and sets the \addttindex{op\_index}
register to 0. This is the only standard opcode whose operand
is \textbf{not} a variable length number. It also does
\textbf{not} multiply the
-operand by the \addtoindex{\texttt{minimum\_instruction\_length}}
+operand by the \addttindex{minimum\_instruction\_length}
field of the header.
\textit{Existing assemblers cannot emit
\item \textbf{DW\_LNS\_set\_prologue\_end} \\
The \livetarg{chap:DWLNSsetprologueend}{DW\_LNS\_set\_prologue\_end}
opcode takes no operands. It sets the
-\addtoindex{\texttt{prologue\_end}} register
+\addttindex{prologue\_end} register
to \doublequote{true}.
\textit{When a breakpoint is set on entry to a function, it is
\item \textbf{DW\_LNS\_set\_epilogue\_begin} \\
The \livetarg{chap:DWLNSsetepiloguebegin}{DW\_LNS\_set\_epilogue\_begin} opcode takes no operands. It
-sets the \addtoindex{\texttt{epilogue\_begin}} register to \doublequote{true}.
+sets the \addttindex{epilogue\_begin} register to \doublequote{true}.
\textit{When a breakpoint is set on the exit of a function or execution
steps over the last executable statement of a function, it is
\item \textbf{DW\_LNS\_set\_isa} \\
The \livetarg{chap:DWLNSsetisa}{DW\_LNS\_set\_isa} opcode takes a single
unsigned LEB128\addtoindexx{LEB128!unsigned} operand and stores that value in the
-\addtoindex{\texttt{isa}}
+\addttindex{isa}
register of the state machine.
\end{enumerate}
\item \textbf{DW\_LNE\_end\_sequence} \\
The \livetarg{chap:DWLNEendsequence}{DW\_LNE\_end\_sequence} opcode takes no operands. It sets the
-\addtoindex{\texttt{end\_sequence}}
+\addttindex{end\_sequence}
register of the state machine to \doublequote{true} and
appends a row to the matrix using the current values of the
state-machine registers. Then it resets the registers to the
address as an operand. The size of the operand is the size
of an address on the target machine. It sets the \texttt{address}
register to the value given by the relocatable address and
-sets the \texttt{op\_index} register to 0.
+sets the \addttindex{op\_index} register to 0.
\textit{All of the other line number program opcodes that
affect the \texttt{address} register add a delta to it. This instruction
to either the compilation directory (as specified by the
\livelink{chap:DWATcompdir}{DW\_AT\_comp\_dir} attribute given in the compilation unit)
or one of the directories in the
-\addtoindex{\texttt{include\_directories}} section.
+\addttindex{include\_directories} section.
\item An unsigned LEB128\addtoindexx{LEB128!unsigned}
number representing the directory index
\end{enumerate}
The directory index represents an entry in the
-\addtoindex{\texttt{include\_directories}} section of the line number program
+\addttindex{include\_directories} section of the line number program
header. The index is 0 if the file was found in the current
directory of the compilation, 1 if it was found in the first
-directory in the \addtoindex{\texttt{include\_directories}} section,
+directory in the \addttindex{include\_directories} section,
and so on. The
directory index is ignored for file names that represent full
path names.
opcode takes a single
parameter, an unsigned LEB128\addtoindexx{LEB128!unsigned}
integer. It sets the
-\addtoindex{\texttt{discriminator}} register to the new value.
+\addttindex{discriminator} register to the new value.
\end{enumerate}
\item \texttt{address\_size} (\addtoindex{ubyte}) \\
The size of a target address
-\addtoindexx{\texttt{address\_size}}
+\addttindexx{address\_size}
in this CIE and any FDEs that
use it, in bytes. If a compilation unit exists for this frame,
its address size must match the address size here.
\item \texttt{segment\_size} (\addtoindex{ubyte}) \\
-The \addtoindexx{\texttt{segment\_size}}
+The \addttindexx{segment\_size}
size of a segment selector in this CIE and any FDEs that
use it, in bytes.
-\item \addtoindex{\texttt{code\_alignment\_factor}} (unsigned LEB128)
+\item \addttindex{code\_alignment\_factor} (unsigned LEB128)
\addtoindexx{LEB128!unsigned}\addtoindexx{unsigned LEB128|see{LEB128, unsigned}}
-\addtoindexx{\texttt{code alignment factor}} \\
+\addtoindexx{code alignment factor} \\
A
-\addtoindexx{\texttt{\textless caf\textgreater}|see{code alignment factor}}
+\addtoindexx{\textless caf\textgreater|see{code alignment factor}}
constant that is factored out of all advance location
instructions (see
Section \refersec{chap:rowcreationinstructions}).
-\item \addtoindex{\texttt{data\_alignment\_factor}} (signed LEB128)
+\item \addttindex{data\_alignment\_factor} (signed LEB128)
\addtoindexx{LEB128!signed}\addtoindexx{signed LEB128|see{LEB128, signed}} \\
\addtoindexx{data alignment factor}
A
-\addtoindexx{\texttt{\textless daf\textgreater}|see{data alignment factor}}
+\addtoindexx{\textless daf\textgreater|see{data alignment factor}}
constant that is factored out of certain offset instructions
(see below). The resulting value is \textit{(operand} *
\texttt{data\_alignment\_factor}).
\item \texttt{initial\_location} (segment selector and target address) \\
The
-\addtoindexx{\texttt{initial\_location}}
+\addttindexx{initial\_location}
address of the first location associated with this table
entry.
-If the \addtoindex{\texttt{segment\_size}} field of this FDE's CIE is non-zero,
+If the \addttindex{segment\_size} field of this FDE's CIE is non-zero,
the initial location is preceded by a segment selector of
the given length.
\item \texttt{address\_range} (target address) \\
The
-\addtoindexx{\texttt{address\_range}}
+\addttindexx{address\_range}
number
\addtoindexx{target address}
of bytes of program instructions described by this entry.
other values in the new row are initially identical to the
current row. The new location value is always greater than
the current one.
-If the \addtoindex{\texttt{segment\_size}} field of this FDE's
+If the \addttindex{segment\_size} field of this FDE's
\addtoindex{CIE}
is non\dash zero, the initial location is preceded by a segment
selector of the given length.
action is to create a new table row with a location value that
is computed by taking the current entry\textquoteright s location value
and adding the value of
-\textit{delta} * \addtoindex{\texttt{code\_alignment\_factor}}.
+\textit{delta} * \addttindex{code\_alignment\_factor}.
All other values in the new row are initially identical to the
current row
signed LEB128\addtoindexx{LEB128!signed} factored offset. This instruction is identical
to \livelink{chap:DWCFAdefcfa}{DW\_CFA\_def\_cfa} except that the second operand is signed
and factored. The resulting offset is \textit{factored\_offset} *
-\addtoindex{\texttt{data\_alignment\_factor}}.
+\addttindex{data\_alignment\_factor}.
\item \textbf{DW\_CFA\_def\_cfa\_register} \\
LEB128\addtoindexx{LEB128!signed} operand representing a factored offset. This instruction
is identical to \livelink{chap:DWCFAdefcfaoffset}{DW\_CFA\_def\_cfa\_offset} except that the
operand is signed and factored. The resulting offset is
-\textit{factored\_offset} * \addtoindex{\texttt{data\_alignment\_factor}}.
+\textit{factored\_offset} * \addttindex{data\_alignment\_factor}.
This operation
is valid only if the current CFA rule is defined to use a
register and offset.
is to change the rule for the register indicated by the
register number to be an offset(N) rule where the value of
N is
-\textit{factored offset} * \addtoindex{\texttt{data\_alignment\_factor}}.
+\textit{factored offset} * \addttindex{data\_alignment\_factor}.
\item \textbf{DW\_CFA\_offset\_extended} \\
The \livetarg{chap:DWCFAoffsetextended}{DW\_CFA\_offset\_extended}
to \livelink{chap:DWCFAoffsetextended}{DW\_CFA\_offset\_extended}
except that the second operand is
signed and factored. The resulting offset is
-\textit{factored\_offset} * \addtoindex{\texttt{data\_alignment\_factor}}.
+\textit{factored\_offset} * \addttindex{data\_alignment\_factor}.
\item \textbf{DW\_CFA\_val\_offset} \\
The \livetarg{chap:DWCFAvaloffset}{DW\_CFA\_val\_offset}
factored offset. The required action is to change the rule
for the register indicated by the register number to be a
val\_offset(N) rule where the value of N is
-\textit{factored\_offset} * \addtoindex{\texttt{data\_alignment\_factor}}.
+\textit{factored\_offset} * \addttindex{data\_alignment\_factor}.
+\needlines{6}
\item \textbf{DW\_CFA\_val\_offset\_sf} \\
The \livetarg{chap:DWCFAvaloffsetsf}{DW\_CFA\_val\_offset\_sf} instruction takes two operands: an
unsigned LEB128\addtoindexx{LEB128!unsigned} value representing a register number and a
signed LEB128\addtoindexx{LEB128!signed} factored offset. This instruction is identical
to \livelink{chap:DWCFAvaloffset}{DW\_CFA\_val\_offset} except that the second operand is signed
and factored. The resulting offset is
-\textit{factored\_offset} * \addtoindex{\texttt{data\_alignment\_factor}}.
+\textit{factored\_offset} * \addttindex{data\_alignment\_factor}.
\item \textbf{DW\_CFA\_register} \\
The \livetarg{chap:DWCFAregister}{DW\_CFA\_register}
register to the rule assigned it by the \texttt{initial\_instructions}
in the CIE.
+\needlines{5}
\item \textbf{DW\_CFA\_restore\_extended} \\
The \livetarg{chap:DWCFArestoreextended}{DW\_CFA\_restore\_extended}
instruction takes a single unsigned LEB128\addtoindexx{LEB128!unsigned}
program but that a case insensitive lookup should be used to
access those names.
-\item A \livelink{chap:DWATbasetypes}{DW\_AT\_base\_types} attribute whose value is a reference.
+\item A \livelink{chap:DWATbasetypes}{DW\_AT\_base\_types} attribute whose value is a
+\livelink{chap:classreference}{reference}.
This
\item A \livelink{chap:DWATuseUTF8}{DW\_AT\_use\_UTF8} attribute,
\addtoindexx{use UTF8 attribute}\addtoindexx{UTF-8}
-which is a \livelink{chap:flag}{flag} whose
+which is a \livelink{chap:classflag}{flag} whose
presence indicates that all strings (such as the names of
declared entities in the source program) are represented
using the UTF\dash 8 representation
(see Section \refersec{datarep:attributeencodings}).
-\item A \livelink{chap:DWATmainsubprogram}{DW\_AT\_main\_subprogram} attribute, which is a \livelink{chap:flag}{flag}
+\item A \livelink{chap:DWATmainsubprogram}{DW\_AT\_main\_subprogram} attribute, which is a \livelink{chap:classflag}{flag}
\addtoindexx{main subprogram attribute}
whose presence indicates
\hypertarget{chap:DWATmainsubprogramunitcontainingmainorstartingsubprogram}
\addtoindexx{import attribute}
a
\livelink{chap:DWATimport}{DW\_AT\_import} attribute
-whose value is a reference to the
+whose value is a \livelink{chap:classreference}{reference} to the
normal or partial compilation unit whose declarations logically
belong at the place of the imported unit entry.
that type, variable, or function definition entry has a
\livelink{chap:DWATspecification}{DW\_AT\_specification} attribute
\addtoindexx{specification attribute}
-whose value is a reference to the
+whose value is a \livelink{chap:classreference}{reference} to the
debugging information entry representing the declaration of
the type, variable or function. Type, variable, or function
entries with a
\addtoindexx{import attribute}
Each imported declaration entry has a
\livelink{chap:DWATimport}{DW\_AT\_import} attribute,
-whose value is a reference to the
+whose value is a \livelink{chap:classreference}{reference} to the
debugging information entry representing the declaration that
is being imported.
with a name attribute whose value is
a null\dash terminated string containing the alias name as it
appears in the source program and an import attribute whose
-value is a reference to the applicable original namespace or
+value is a \livelink{chap:classreference}{reference} to the applicable original namespace or
namespace extension entry.
}
imported module entry contains a
\livelink{chap:DWATimport}{DW\_AT\_import} attribute
\addtoindexx{import attribute}
-whose value is a reference to the module or namespace entry
+whose value is a \livelink{chap:classreference}{reference}
+to the module or namespace entry
containing the definition and/or declaration entries for
the entities that are to be imported into the context of the
imported module entry.
\addtoindexx{external attribute}
a
\livelink{chap:DWATexternal}{DW\_AT\_external} attribute,
-which is a \livelink{chap:flag}{flag}.
+which is a \livelink{chap:classflag}{flag}.
\textit{Additional attributes for functions that are members of a
class or structure are described in
attribute
\addtoindexx{main subprogram attribute}
which is
-a \livelink{chap:flag}{flag} whose presence indicates that the
+a \livelink{chap:classflag}{flag} whose presence indicates that the
subroutine has been identified as the starting function of
the program. If more than one subprogram contains this
\nolink{flag},
\hypertarget{chap:DWATcallingconventionsubprogramcallingconvention}
contain a
\livelink{chap:DWATcallingconvention}{DW\_AT\_calling\_convention}
-attribute, whose value is an integer constant. The set of
+attribute, whose value is an
+\livelink{chap:classconstant}{integer constant}. The set of
calling convention codes is given in
Table \refersec{tab:callingconventioncodes}.
\addtoindexx{prototyped attribute}
a
\livelink{chap:DWATprototyped}{DW\_AT\_prototyped} attribute, which is
-a \livelink{chap:flag}{flag}.
+a \livelink{chap:classflag}{flag}.
\textit{The \addtoindex{Fortran}
language allows the keywords \texttt{elemental}, \texttt{pure}
\addtoindexx{elemental attribute}
a
\livelink{chap:DWATelemental}{DW\_AT\_elemental} attribute, which
-is a \livelink{chap:flag}{flag}.
+is a \livelink{chap:classflag}{flag}.
The attribute indicates whether the subroutine
or entry point was declared with the ``elemental'' keyword
or property.
\addtoindexx{pure attribute}
a
\livelink{chap:DWATpure}{DW\_AT\_pure} attribute, which is
-a \livelink{chap:flag}{flag}.
+a \livelink{chap:classflag}{flag}.
The attribute indicates whether the subroutine was
declared with the ``pure'' keyword or property.
\hypertarget{chap:DWATrecursiverecursivepropertyofasubroutine}
subprogram entry may have a
\livelink{chap:DWATrecursive}{DW\_AT\_recursive} attribute, which
-is a \livelink{chap:flag}{flag}.
+is a \livelink{chap:classflag}{flag}.
The attribute indicates whether the subroutine
or entry point was declared with the ``recursive'' keyword
or property.
with the tag
\livetarg{chap:DWTAGunspecifiedparameters}{DW\_TAG\_unspecified\_parameters}.
-The entry for a subroutine that includes
+The entry for a subroutine that includes a
+\addtoindex{Fortran}
\addtoindexx{Fortran!common block}
-a
-\addtoindex{Fortran} common block
\livelink{chap:fortrancommonblock}{common}
\livelink{chap:commonblockentry}{block}
\addtoindexx{common block|see{Fortran common block}}
\hypertarget{chap:commonreferencecommonblockusage}
common inclusion entry has a
\livelink{chap:DWATcommonreference}{DW\_AT\_common\_reference} attribute
-whose value is a reference to the debugging information entry
+whose value is a \livelink{chap:classreference}{reference}
+to the debugging information entry
for the common \nolink{block} being included
(see Section \refersec{chap:commonblockentries}).
thrown type entry contains
\addtoindexx{type attribute}
a \livelink{chap:DWATtype}{DW\_AT\_type} attribute, whose
-value is a reference to an entry describing the type of the
+value is a \livelink{chap:classreference}{reference}
+to an entry describing the type of the
exception that may be thrown.
\subsection{Function Template Instantiations}
that was expanded inline implicitly by the compiler has
\addtoindexx{inline attribute}
a
-\livelink{chap:DWATinline}{DW\_AT\_inline} attribute whose value is an integer constant. The
+\livelink{chap:DWATinline}{DW\_AT\_inline} attribute whose value is an
+\livelink{chap:classconstant}{integer constant}. The
set of values for the \livelink{chap:DWATinline}{DW\_AT\_inline} attribute is given in
Table \refersec{tab:inlinecodes}.
\end{table}
\textit{In \addtoindex{C++}, a function or a constructor declared with
-\addtoindex{\texttt{constexpr}} is implicitly declared inline. The abstract inline
+\addttindex{constexpr} is implicitly declared inline. The abstract inline
instance (see below) is represented by a debugging information
entry with the tag \livelink{chap:DWTAGsubprogram}{DW\_TAG\_subprogram}. Such an entry has a
\livelink{chap:DWATinline}{DW\_AT\_inline} attribute whose value is \livelink{chap:DWINLinlined}{DW\_INL\_inlined}.}
may also have \livelink{chap:DWATcallfile}{DW\_AT\_call\_file},
\livelink{chap:DWATcallline}{DW\_AT\_call\_line} and \livelink{chap:DWATcallcolumn}{DW\_AT\_call\_column} attributes,
each of whose
-value is an integer constant. These attributes represent the
+value is an \livelink{chap:classconstant}{integer constant}.
+These attributes represent the
source file, source line number, and source column number,
respectively, of the first character of the statement or
expression that caused the inline expansion. The call file,
\hypertarget{chap:DWATconstexprcompiletimeconstantfunction}
may have a
\livelink{chap:DWATconstexpr}{DW\_AT\_const\_expr}
-attribute, which is a \livelink{chap:flag}{flag}
+attribute, which is a \livelink{chap:classflag}{flag}
whose presence indicates that the
subroutine has been evaluated as a compile\dash time constant. Such
an entry may also have a \livelink{chap:DWATconstvalue}{DW\_AT\_const\_value} attribute,
represented as it would be on the target architecture.
\textit{In \addtoindex{C++}, if a function or a constructor declared with
-\addtoindex{\texttt{constexpr}}
+\addttindex{constexpr}
is called with constant expressions, then the corresponding
concrete inlined instance has a
\livelink{chap:DWATconstexpr}{DW\_AT\_const\_expr} attribute,
If an entry within a concrete inlined instance tree contains
attributes describing the
\addtoindexx{declaration coordinates!in concrete instance}
-declaration coordinates
-of that
-entry, then those attributes should refer to the file, line
+\livelink{chap:declarationcoordinates}{declaration coordinates}
+of that entry, then those attributes should refer to the file, line
and column of the original declaration of the subroutine,
not to the point at which it was inlined. As a consequence,
they may usually be omitted from any entry that has an abstract
origin attribute.
+\needlines{4}
For each pair of entries that are associated via a
\addtoindexx{abstract origin attribute}
\livelink{chap:DWATabstractorigin}{DW\_AT\_abstract\_origin} attribute, both members of the pair
also to the abstract and concrete instance entries for the
nested subroutine.
+\needlines{5}
For an inlined subroutine nested within another inlined
subroutine, the following rules apply to their abstract and
\addtoindexx{abstract instance!nested}
(possibly mangled) \addtoindexx{mangled names}
name of the target subprogram.
-\item If the value is of class \livelink{chap:flag}{flag}, then the value true
+\item If the value is of class \livelink{chap:classflag}{flag}, then the value true
indicates that the containing subroutine is a trampoline but
that the target subroutine is not known.
\end{itemize}
\addtoindexx{encoding attribute}
a \livelink{chap:DWATencoding}{DW\_AT\_encoding} attribute describing
how the base type is encoded and is to be interpreted. The
-value of this attribute is an integer constant. The set of
+value of this attribute is an
+\livelink{chap:classconstant}{integer constant}. The set of
values and their meanings for the
\livelink{chap:DWATencoding}{DW\_AT\_encoding} attribute
is given in
\hypertarget{chap:DWATbitsizebasetypebitsize}
or a \livelink{chap:DWATbitsize}{DW\_AT\_bit\_size} attribute
\addtoindex{bit size attribute}
-whose integer constant value
+whose \livelink{chap:classconstant}{integer constant} value
(see Section \refersec{chap:byteandbitsizes})
is the amount of storage needed to hold
a value of the type.
both
\addtoindexx{data bit offset attribute}
of whose values are
-integer constant values (
-see Section \refersec{chap:staticanddynamicvaluesofattributes}).
+\livelink{chap:classconstant}{integer constant} values
+(see Section \refersec{chap:staticanddynamicvaluesofattributes}).
The bit size
attribute describes the actual size in bits used to represent
values of the given type. The data bit offset attribute is the
A \livelink{chap:DWATdecimalsign}{DW\_AT\_decimal\_sign} attribute
\addtoindexx{decimal sign attribute}
-is an integer constant that
+is an \livelink{chap:classconstant}{integer constant} that
conveys the representation of the sign of the decimal type
(see Figure \refersec{tab:decimalsignattributevalues}).
-Its integer constant value is interpreted to
+Its \livelink{chap:classconstant}{integer constant} value is interpreted to
mean that the type has a leading overpunch, trailing overpunch,
leading separate or trailing separate sign representation or,
alternatively, no sign at all.
\livelink{chap:DWATdigitcount}{DW\_AT\_digit\_count}
attribute
\addtoindexx{digit count attribute}
-is an integer constant
+is an \livelink{chap:classconstant}{integer constant}
value that represents the number of digits in an instance of
the type.
\livelink{chap:DWATbinaryscale}{DW\_AT\_binary\_scale} attribute.
The
\livelink{chap:DWATbinaryscale}{DW\_AT\_binary\_scale} attribute
-is an integer constant value
+is an \livelink{chap:classconstant}{integer constant} value
that represents the exponent of the base two scale factor to
be applied to an instance of the type. Zero scale puts the
binary point immediately to the right of the least significant
\addtoindexx{type attribute}
a
\livelink{chap:DWATtype}{DW\_AT\_type} attribute,
-whose value is a reference to a debugging information entry
+whose value is a \livelink{chap:classreference}{reference}
+to a debugging information entry
describing a base type, a user-defined type or another type
modifier.
\addtoindexx{type attribute}
a
\livelink{chap:DWATtype}{DW\_AT\_type} attribute whose
-value is a reference to the type named by the typedef. If
+value is a \livelink{chap:classreference}{reference}
+to the type named by the typedef. If
the debugging information entry for a typedef represents
a declaration of the type that is not also a definition,
it does not contain a type attribute.
\hypertarget{chap:DWATorderingarrayrowcolumnordering}
array type entry describing a multidimensional array may
\addtoindexx{array!element ordering}
-have a \livelink{chap:DWATordering}{DW\_AT\_ordering} attribute whose integer constant value is
+have a \livelink{chap:DWATordering}{DW\_AT\_ordering} attribute whose
+\livelink{chap:classconstant}{integer constant} value is
interpreted to mean either row-major or column-major ordering
of array elements. The set of values and their meanings
for the ordering attribute are listed in
be represented by a debugging information entry for a
multidimensional array.}
+\needlines{5}
Other attributes especially applicable to arrays are
\livelink{chap:DWATallocated}{DW\_AT\_allocated},
\livelink{chap:DWATassociated}{DW\_AT\_associated} and
incomplete structure, class or union, the entry may have a
\livelink{chap:DWATspecification}{DW\_AT\_specification} attribute
\addtoindexx{specification attribute}
-whose value is a reference to
+whose value is a \livelink{chap:classreference}{reference} to
the debugging information entry representing that incomplete
declaration.
may
\addtoindexx{mutable attribute}
have a \livelink{chap:DWATmutable}{DW\_AT\_mutable} attribute,
-which is a \livelink{chap:flag}{flag}.
+which is a \livelink{chap:classflag}{flag}.
This attribute indicates whether the data
member was declared with the mutable storage class specifier.
\addtoindexx{data member location attribute}
there are two cases:
\begin{enumerate}[1. ]
-\item If the value is an integer constant, it is the offset
+\item If the value is an \livelink{chap:classconstant}{integer constant},
+it is the offset
in bytes from the beginning of the containing entity. If
the beginning of the containing entity has a non-zero bit
offset then the beginning of the member entry has that same
\end{enumerate}
For a \livelink{chap:DWATdatabitoffset}{DW\_AT\_data\_bit\_offset} attribute,
-the value is an integer constant
+the value is an \livelink{chap:classconstant}{integer constant}
(see Section \refersec{chap:staticanddynamicvaluesofattributes})
that specifies the number of bits
from the beginning of the containing entity to the beginning
\addtoindexx{bit size attribute}
either a \livelink{chap:DWATbytesize}{DW\_AT\_byte\_size}
or a \livelink{chap:DWATbitsize}{DW\_AT\_bit\_size} attribute whose
-integer constant value
+\livelink{chap:classconstant}{integer constant} value
(see Section \refersec{chap:staticanddynamicvaluesofattributes})
is the amount
of storage needed to hold the value of the data member.
(see Section
\refersec{chap:basetypeentries}).
It replaces the
-\livetarg{chap:DWATbitoffsetdatamemberbitlocation}
+\livetarg{chap:DWATbitoffsetdatamemberbitlocation}{}
attributes \livelink{chap:DWATbitoffset}{DW\_AT\_bit\_offset} and
\livelink{chap:DWATbytesize}{DW\_AT\_byte\_size} when used to
identify the beginning of bit field data members as defined
\addtoindexx{object pointer attribute}
a \livelink{chap:DWATobjectpointer}{DW\_AT\_object\_pointer}
attribute
-whose value is a reference to the formal parameter entry
+whose value is a \livelink{chap:classreference}{reference}
+to the formal parameter entry
that corresponds to the object for which the function is
called. The name attribute of that formal parameter is defined
by the current language (for example,
\addtoindexx{discriminant attribute}
have a
\livelink{chap:DWATdiscr}{DW\_AT\_discr} attribute
-whose value is a reference to
+whose value is a \livelink{chap:classreference}{reference} to
the member entry for the discriminant.
If the variant part does not have a discriminant (tag field),
is a signed type. The number is unsigned if the tag type is
an unsigned type.
+\needlines{5}
Alternatively,
\hypertarget{chap:DWATdiscrlistlistofdiscriminantvalues}
the variant entry may contain
\livelink{chap:DWATdiscrlist}{DW\_AT\_discr\_list}
attribute, whose value represents a list of discriminant
values. This list is represented by any of the
-\livelink{chap:block}{block} forms and
+\livelink{chap:classblock}{block} forms and
may contain a mixture of case labels and label ranges. Each
item on the list is prefixed with a discriminant value
descriptor that determines whether the list item represents
Table \refersec{tab:discriminantdescriptorvalues}.
\begin{simplenametable}[1.4in]{Discriminant descriptor values}{tab:discriminantdescriptorvalues}
-\addtoindex{DW\_DSC\_label} \\
-\addtoindex{DW\_DSC\_range} \\
+\livetarg{chap:DWDSClabel}{DW\_DSC\_label} \\
+\livetarg{chap:DWDSCrange}{DW\_DSC\_range} \\
\end{simplenametable}
If a variant entry has neither a \livelink{chap:DWATdiscrvalue}{DW\_AT\_discr\_value}
\addtoindexx{name attribute}
whose value is a null\dash terminated
string containing the enumeration type name as it appears
-in the source program. This entry also has a \livelink{chap:DWATbytesize}{DW\_AT\_byte\_size}
-attribute whose integer constant value is the number of bytes
+in the source program. This entry also has a
+\livelink{chap:DWATbytesize}{DW\_AT\_byte\_size}
+attribute whose \livelink{chap:classconstant}{integer constant}
+value is the number of bytes
required to hold an instance of the enumeration.
The \addtoindex{enumeration type entry}
then the \addtoindex{enumeration type entry} may
\addtoindexx{enum class|see{type-safe enumeration}}
have a \livelink{chap:DWATenumclass}{DW\_AT\_enum\_class}
-attribute, which is a \livelink{chap:flag}{flag}.
+attribute, which is a \livelink{chap:classflag}{flag}.
In a language that offers only
one kind of enumeration declaration, this attribute is not
required.
\addtoindexx{prototyped attribute}
a
\livelink{chap:DWATprototyped}{DW\_AT\_prototyped} attribute, which is
-a \livelink{chap:flag}{flag}.
+a \livelink{chap:classflag}{flag}.
Each debugging information entry owned by a subroutine
type entry correspond to either a formal parameter or the sequence of
\section{String Type Entries}
-\label{chap:stringtypeentries}
+\label{chap:classstringtypeentries}
\textit{A ``string'' is a sequence of characters that have specific
\addtoindexx{string type entry}
is the same as the
\addtoindex{size of an address} on the target machine.
+\needlines{5}
If no string length attribute is present, the string type
entry may have a \livelink{chap:DWATbytesize}{DW\_AT\_byte\_size} attribute or
\livelink{chap:DWATbitsize}{DW\_AT\_bit\_size}
\addtoindexx{threads scaled attribute}
a
\livelink{chap:DWATthreadsscaled}{DW\_AT\_threads\_scaled} attribute,
-which is a \livelink{chap:flag}{flag}.
+which is a \livelink{chap:classflag}{flag}.
If present, this attribute indicates whether
this subrange represents a \addtoindex{UPC} array bound which is scaled
by the runtime THREADS value (the number of UPC threads in
\hypertarget{chap:DWATcontainingtypecontainingtypeofpointertomembertype}
has a
\livelink{chap:DWATcontainingtype}{DW\_AT\_containing\_type}
-attribute, whose value is a reference to a debugging
+attribute, whose value is a \livelink{chap:classreference}{reference} to a debugging
information entry for the class or structure to whose members
objects of this type may point.
When this attribute is omitted, the address of the data is
the same as the address of the object.
+\needlines{5}
\textit{This location description will typically begin with
\livelink{chap:DWOPpushobjectaddress}{DW\_OP\_push\_object\_address}
which loads the address of the
\addtoindexx{type attribute}
a
\livelink{chap:DWATtype}{DW\_AT\_type} attribute
-whose value is a reference to the type
-named by the template alias.
+whose value is a \livelink{chap:classreference}{reference}
+to the type named by the template alias.
\needlines{4}
The template alias entry has the following child entries:
DWARF Git Projects / dwarf-doc.git / commitdiff