ELF object file representation.
The notion of \addtoindex{section group} is
an abstraction of common extensions of the ELF representation
-widely known as ``COMDATs'' or ``COMDAT sections''. (Other
+widely known as \doublequote{COMDATs} or \doublequote{COMDAT sections.} (Other
object file representations provide COMDAT\dash style mechanisms as
well.) There are several variations in the COMDAT schemes in
common use, any of which should be sufficient for the purposes
\textless gid\dash number\textgreater,
and
-\item a non\dash matching output (say because of \#defines)
+\item a non\dash matching output (say because of \texttt{\#defines})
generates a different
\textless gid\dash number\textgreater.
\end{itemize}
\textit{It may be useful to think of a
\textless gid\dash number\textgreater
as a kind
-of ``digital signature'' that allows a fast test for the
+of \doublequote{digital signature} that allows a fast test for the
equality of two
\addtoindexx{section group}
section groups.}
unit's debugging information entries to those of another
compilation unit.
+\needlines{4}
When referencing into a removable \addtoindex{section group}
\dotdebuginfo{}
from another \dotdebuginfo{} (from anywhere), the
-\texttt{<prefix>.<file-designator>.<gid-number>.<die-number>}
+\begin{alltt}
+ <prefix>.<file-designator>.<gid-number>.<die-number>
+\end{alltt}
name should be used for an external symbol and a relocation
generated based on that name.
+\needlines{4}
\textit{When referencing into a
\addtoindexx{section group}
non-section group
\livelink{chap:DWFORMrefaddr}{DW\_FORM\_ref\_addr} is
still the form to be used, but a section\dash relative relocation
generated by use of a non-exported name (often called an
-``internal name'') may be used for references within the
+\doublequote{internal name}) may be used for references within the
same object file.}
\subsection{Examples}
\end{figure}
Figure \refersec{fig:duplicateeliminationexample1primarycompilationunit}
-shows the ``normal'' DWARF sections, which are not part of
+shows the \doublequote{normal} DWARF sections, which are not part of
any \addtoindex{section group},
and how they make use of the information
in the \addtoindex{section group} shown above.
\label{fig:duplicateeliminationexample1primarycompilationunit}
\end{figure}
-This example uses \livelink{chap:DWTAGcompileunit}{DW\_TAG\_compile\_unit} for the \addtoindex{section group},
+\needlines{4}
+This example uses \livelink{chap:DWTAGcompileunit}{DW\_TAG\_compile\_unit}
+for the \addtoindex{section group},
implying that the contents of the compilation unit are
globally visible (in accordance with
\addtoindex{C++} language rules).
-\livelink{chap:DWTAGpartialunit}{DW\_TAG\_partial\_unit} is not needed for the same reason.
+\livelink{chap:DWTAGpartialunit}{DW\_TAG\_partial\_unit}
+is not needed for the same reason.
\subsubsection{Fortran Example}
Figure \refersec{fig:duplicateeliminationexample2fortransource}.
\begin{figure}
-\textit{File CommonStuff.fh}
+\textit{File CommonStuff.f\hspace{1pt}h}
\addtoindexx{Fortran}
\begin{lstlisting}[numbers=none]
IMPLICIT INTEGER(A-Z)
\needlines{6}
-\subsubsection{C Example}
+\subsubsection{C++ Example}
-The \addtoindex{C} example
-\addtoindexx{DWARF duplicate elimination!C example}
+The \addtoindex{C++} example
+\addtoindexx{DWARF duplicate elimination!C++ example}
in this Section might appear to be equally
valid as a \addtoindex{C} example. However, it is prudent to include
a \livelink{chap:DWTAGimportedunit}{DW\_TAG\_imported\_unit}
(Section \refersec{app:usingcompilationunits}),
many
linkers today support the concept of a COMDAT group or
-linkonce section. The general idea is that a ``key'' can be
+linkonce section. The general idea is that a \doublequote{key} can be
attached to a section or a group of sections, and the linker
will include only one copy of a \addtoindex{section group}
(or individual section) for any given key.
Next, consider one possible representation of the DWARF
information that describes the type \doublequote{struct C} as shown
in
-\refersec{fig:typesignaturecomputation1dwarfrepresentation}:
+\refersec{fig:typesignaturecomputation1dwarfrepresentation}.
\begin{figure}
\begin{dwflisting}
0xd28081e8 dcf5070a.
Next, consider a representation of the DWARF information that
-describes the type ``class A'' as shown in
+describes the type \doublequote{class A} as shown in
Figure \refersec{fig:typesignaturecomputation2dwarfrepresentation}.
\begin{figure}
\end{alltt}
\end{dwflisting}
\begin{center}
-Figure~\ref{fig:typesignaturecomputation2dwarfrepresentation} Type signature computation \#2: DWARF representation \textit{(concluded)}
+\vspace{2mm}
+Figure~\ref{fig:typesignaturecomputation2dwarfrepresentation}: Type signature computation \#2: DWARF representation \textit{(concluded)}
\end{center}
\end{figure}
\addtoindexx{type unit}
type units. For \texttt{N::A}, the actual
definition of the type begins at label L1. The definition
-involves references to the int base type and to two pointer
+involves references to the \texttt{int} base type and to two pointer
types. The information for each of these referenced types is
also included in this \addtoindex{type unit},
since base types and pointer
\end{alltt}
\end{dwflisting}
\begin{center}
-Figure~\ref{fig:typesignatureexample2flattenedbytestream} Type signature example \#2: flattened byte stream \textit{(continued)}
+\vspace{2mm}
+Figure~\ref{fig:typesignatureexample2flattenedbytestream}: Type signature example \#2: flattened byte stream \textit{(continued)}
\end{center}
\end{figure}
\end{alltt}
\end{dwflisting}
\begin{center}
-Figure~\ref{fig:typesignatureexample2flattenedbytestream} Type signature example \#2: flattened byte stream \textit{(concluded)}
+\vspace{2mm}
+Figure~\ref{fig:typesignatureexample2flattenedbytestream}: Type signature example \#2: flattened byte stream \textit{(concluded)}
\end{center}
\end{figure}
Texts, and with no \mbox{Back-Cover} Texts.
A copy of the license is included in the section entitled
-``GNU Free Documentation License''.
+\doublequote{GNU Free Documentation License.}
This document is based in part on the \dwf, Version 2,
which contained the following notice:
UNIX International makes
no representations about the suitability of this documentation
for any purpose.
-It is provided ``as is'' without express
+It is provided \doublequote{as is} without express
or implied warranty.
\end{myindentpara}
for the object from the beginning of the first \addtoindex{range list} entry
that is not a base selection entry or an end of list entry.
+\needlines{4}
\item Otherwise, the scope of the object is specified using
a value of class \livelink{chap:classrangelistptr}{rangelistptr}.
This value indicates the
beginning of a \addtoindex{range list}
-(see \refersec{chap:noncontiguousaddressranges}).
+(see \ref{chap:noncontiguousaddressranges}).
\end{enumerate}
integer that gives the actual length
(see Section \refersec{datarep:32bitand64bitdwarfformats}).
+\needlines{4}
\item \texttt{version} (\addtoindex{uhalf}) \\
A 2\dash byte unsigned integer representing the version of the
DWARF information for the compilation unit \addtoindexx{version number!compilation unit}
8\dash byte unsigned integer that gives the actual length
(see Section \refersec{datarep:32bitand64bitdwarfformats}).
+\needlines{4}
\item \texttt{version} (\addtoindex{uhalf}) \\
A 2\dash byte unsigned integer representing the version of the
DWARF information for the
\end{longtable}
\end{centering}
+\needlines{4}
Finally, the child encoding is followed by a series of
attribute specifications. Each attribute specification
consists of two parts. The first part is an unsigned LEB128
This address is relocatable in a relocatable object file and
is relocated in an executable file or shared object.
+\needlines{4}
\item \livelink{chap:classblock}{block} \\
\livetarg{datarep:classblock}{}
Blocks come in four forms:
\addtoindexx{variable length data|see {LEB128}}
Integers may be
\addtoindexx{Little Endian Base 128|see{LEB128}}
-encoded using ``Little Endian Base 128''
+encoded using \doublequote{Little Endian Base 128}
\addtoindexx{little-endian encoding|see{endian attribute}}
(LEB128) numbers.
\addtoindexx{LEB128}
\textit{This encoding is equally suitable whether the target machine
architecture represents data in big\dash\ endian or little\dash endian
-order. It is ``little\dash endian'' only in the sense that it
-avoids using space to represent the ``big'' end of an
+order. It is \doublequote{little\dash endian} only in the sense that it
+avoids using space to represent the \doublequote{big} end of an
unsigned integer, when the big end is all zeroes or sign
extension bits.}
\livelink{chap:DWATordering}{DW\_AT\_ordering} attribute are given in
Table \refersec{tab:orderingencodings}.
+\needlines{8}
\begin{centering}
\setlength{\extrarowheight}{0.1cm}
\begin{longtable}{l|c}
(see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
The value in this field is 2.
-% Some say unsigned offset this just says offset: FIXME
+\needlines{4}
\item \addtoindex{debug\_info\_offset} (section offset) \\
A
\addtoindexx{section offset!in name lookup table set of entries}
in the line number program header is 4
(see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
-The boolean values ``true'' and ``false''
+The boolean values \doublequote{true} and \doublequote{false}
used by the line number information program are encoded
as a single byte containing the value 0
-for ``false,'' and a non-zero value for ``true.''
+for \doublequote{false,} and a non-zero value for \doublequote{true.}
The encodings for the standard opcodes are given in
\addtoindexx{line number opcodes!standard opcode encoding}
\begin{centering}
\setlength{\extrarowheight}{0.1cm}
\begin{longtable}{l|c}
- \caption{Line Number Standard Opcode encodings} \label{tab:linenumberstandardopcodeencodings}\\
- \hline \bfseries Opcode Name&\bfseries Value \\ \hline
+ \caption{Line number standard opcode encodings} \label{tab:linenumberstandardopcodeencodings}\\
+ \hline \bfseries Opcode name&\bfseries Value \\ \hline
\endfirsthead
- \bfseries Opcode Name&\bfseries Value\\ \hline
+ \bfseries Opcode name&\bfseries Value\\ \hline
\endhead
\hline \emph{Continued on next page}
\endfoot
\begin{centering}
\setlength{\extrarowheight}{0.1cm}
\begin{longtable}{l|c}
- \caption{Line Number Extended Opcode encodings} \label{tab:linenumberextendedopcodeencodings}\\
- \hline \bfseries Opcode Name&\bfseries Value \\ \hline
+ \caption{Line number extended opcode encodings} \label{tab:linenumberextendedopcodeencodings}\\
+ \hline \bfseries Opcode name&\bfseries Value \\ \hline
\endfirsthead
- \bfseries Opcode Name&\bfseries Value\\ \hline
+ \bfseries Opcode name&\bfseries Value\\ \hline
\endhead
\hline \emph{Continued on next page}
\endfoot
\begin{centering}
\setlength{\extrarowheight}{0.1cm}
\begin{longtable}{l|c}
- \caption{Macinfo Type Encodings} \label{tab:macinfotypeencodings}\\
+ \caption{Macinfo type encodings} \label{tab:macinfotypeencodings}\\
\hline \bfseries Macinfo Type Name&\bfseries Value \\ \hline
\endfirsthead
\bfseries Macinfo Type Name&\bfseries Value\\ \hline
The sizes of the integers used in the lookup by name, lookup
by address, line number and call frame information sections
are given in
-Table 41 \refersec{tab:integerrepresentationnames}.
+Table \ref{tab:integerrepresentationnames}.
\begin{centering}
\setlength{\extrarowheight}{0.1cm}
\begin{longtable}{c|l}
- \caption{Integer Representation Names} \label{tab:integerrepresentationnames}\\
- \hline \bfseries Representation Name&\bfseries Representation \\ \hline
+ \caption{Integer representation names} \label{tab:integerrepresentationnames}\\
+ \hline \bfseries Representation name&\bfseries Representation \\ \hline
\endfirsthead
- \bfseries Representation Name&\bfseries Representation\\ \hline
+ \bfseries Representation name&\bfseries Representation\\ \hline
\endhead
\hline \emph{Continued on next page}
\endfoot
% 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 10, 2013 \hspace{1cm}(***\textbf{DRAFT}***)}
+\newcommand{\docdate}{May 18, 2013 \hspace{1cm}(***\textbf{DRAFT}***)}
%
\usepackage[T1]{fontenc}
\usepackage{palatino}
\usepackage{needspace} % For assuring space remaining on a page
\usepackage{ifthen} % For conditional processing
\usepackage{changepage} % For odd/even page checks
-%\usepackage{epic} % For eepic package
-%\usepackage{eepic} % For the diagram of section relationships
-%\usepackage{eepicemu} % For the diagram of section relationships
-\usepackage{tikz} % graphics (Appendix B)
+\usepackage{tikz} % graphics (Appendix B)
\usetikzlibrary{shapes.geometric}
\usetikzlibrary{arrows}
\usepackage{makeidx} % For making an index
\renewcommand{\descriptionlabel}[1]{\hspace{\labelsep}\textnormal{#1}}
\newcommand{\descriptionlabelnl}[1]{\item[#1] \mbox{}\\}
-% Reduce vertical space at beginning of a list
-\setlength{\topsep}{0in}
-
\newcommand{\emptypage}{
\clearpage
\vspace*{4in}
\setlength{\parindent}{0pt}
\setlength{\headheight}{6cm}
\setlength{\uppermargin}{6cm}
+\setlength{\topsep}{0pt}
+\tightlists % less spacing before/after lists
\begin{centering}
\LARGE
\include{dataobject} \emptypage
\include{typeentries} \emptypage
\include{otherdebugginginformation} \emptypage
-\include{datarepresentation} %\emptypage
+\include{datarepresentation} \emptypage
% The \appendix toggles us into appendix chapters
\appendix
longer than and includes that of the raw data, there must be
an address somewhere in the descriptor that points to the
raw data when, in fact, there is some (that is, when
-the ``variable'' is allocated or associated).
+the \doublequote{variable} is allocated or associated).
For concreteness, suppose that a descriptor looks something
like the C structure in
may be convenient for general runtime support unrelated to
debugging.) In this case the above vocabulary applies as
stated. Alternatively, an implementation can do without a
-descriptor, in which case the \doublequote{address of the variable},
+descriptor, in which case the \doublequote{address of the variable,}
or equivalently the \doublequote{base address of the object}, refers
to the \doublequote{raw data} (the real data, the only thing around
that can be the object).
is either \texttt{INNER} or \texttt{OUTER} to indicate to which
subprogram the debugging information entry applies,
\item[\textless ac\textgreater]
-is either AI or CI to indicate ``abstract instance'' or
-``concrete instance'' respectively,
+is either AI or CI to indicate \doublequote{abstract instance} or
+\doublequote{concrete instance} respectively,
\item[\textless n\textgreater]
is the number of the
alternative being considered, and
Each form class may be represented in one or more ways.
For example, some attribute values consist
of a single piece of constant data.
-``Constant data''
+\doublequote{Constant data}
is the class of attribute value that those attributes may have.
There are several representations of constant data,
however (one, two, ,four, or eight bytes, and variable length
\livetarg{chap:DWATlowerbound}{DW\_AT\_lower\_bound}
&\livelinki{chap:DWATlowerboundlowerboundofsubrange}{Lower bound of subrange}{lower bound of subrange} \\
\livetarg{chap:DWATmacroinfo}{DW\_AT\_macro\_info}
-&\livelinki{chap:DWATmacroinfomacroinformation}{Macro information} {macro information} (\#define, \#undef)\\
+&\livelinki{chap:DWATmacroinfomacroinformation}{Macro information} {macro information} (\texttt{\#define}, \texttt{\#undef})\\
\livetarg{chap:DWATmainsubprogram}{DW\_AT\_main\_subprogram}
&\livelinki{chap:DWATmainsubprogrammainorstartingsubprogram}{Main or starting subprogram}{main or starting subprogram} \\
&\livelinki{chap:DWATmainsubprogramunitcontainingmainorstartingsubprogram}{Unit containing main or starting subprogram}{unit containing main or starting subprogram}\\
\livetarg{chap:DWATnamelistitem}{DW\_AT\_namelist\_item}
&\livelinki{chap:DWATnamelistitemnamelistitem}{Namelist item}{namelist item}\\
\livetarg{chap:DWATobjectpointer}{DW\_AT\_object\_pointer}
-&\livelinki{chap:DWATobjectpointerobjectthisselfpointerofmemberfunction}{Object (this, self) pointer of member function}{object (this, self) pointer of member function}\\
+&\livelinki{chap:DWATobjectpointerobjectthisselfpointerofmemberfunction}{Object (\texttt{this}, \texttt{self}) pointer of member function}{object (\texttt{this}, \texttt{self}) pointer of member function}\\
\livetarg{chap:DWATordering}{DW\_AT\_ordering}
&\livelinki{chap:DWATorderingarrayrowcolumnordering}{Array row/column ordering} {array row/column ordering}\\
\livetarg{chap:DWATpicturestring}{DW\_AT\_picture\_string}
a simple stack machine. Each element of the stack is the
\addtoindex{size of an address} on the target machine.
The value on the
-top of the stack after ``executing'' the
+top of the stack after \doublequote{executing} the
\addtoindex{DWARF expression}
is
\addtoindexx{DWARF expression|see{location description}}
retrieved is zero extended to the size of an address on the
target machine before being pushed onto the expression stack.
+\needlines{7}
\itembfnl{\livetarg{chap:DWOPxderef}{DW\_OP\_xderef}}
The \livetarg{chap:DWOPxderef}{DW\_OP\_xderef} operation provides an extended dereference
mechanism. The entry at the top of the stack is treated as an
it as a signed value and pushes its absolute value. If the
absolute value cannot be represented, the result is undefined.
+\needlines{4}
\itembfnl{\livetarg{chap:DWOPand}{DW\_OP\_and}}
The \livetarg{chap:DWOPand}{DW\_OP\_and} operation pops the top two stack values, performs
a bitwise and operation on the two, and pushes the result.
registers, numbered from 0 through 31, inclusive. The object
addressed is in register \textit{n}.
+\needlines{4}
\itembfnl{\livetarg{chap:DWOPregx}{DW\_OP\_regx}}
The \livetarg{chap:DWOPregx}{DW\_OP\_regx} operation has a single unsigned LEB128 literal
operand that encodes the name of a register.
object that is present in the source but not in the object code
(perhaps due to optimization).
+\needlines{5}
\subsubsection{Composite Location Descriptions}
A composite location description describes an object or
value which may be contained in part of a register or stored
Add the contents of r1 and r2 to compute a value. This value is the
\doublequote{contents} of an otherwise anonymous location.
+\needlines{6}
\descriptionitemnl{\livelink{chap:DWOPlit1}{DW\_OP\_lit1} \livelink{chap:DWOPstackvalue}{DW\_OP\_stack\_value} \livelink{chap:DWOPpiece}{DW\_OP\_piece} 4 }
-\vspace{-\parsep}
+\vspace{-0.1\parsep}
\descriptionitemnl{\livelink{chap:DWOPbreg}{DW\_OP\_breg3} 0 \livelink{chap:DWOPbreg}{DW\_OP\_breg4} 0 \livelink{chap:DWOPplus}{DW\_OP\_plus} \livelink{chap:DWOPstackvalue}{DW\_OP\_stack\_value} \livelink{chap:DWOPpiece}{DW\_OP\_piece} 4}
The object value is found in an anonymous (virtual) location whose
value consists of two parts, given in memory address order: the 4 byte
constant drawn from the set of codes listed in
Table \refersec{tab:visibilitycodes}.
-\begin{simplenametable}[1.5in]{Visibility Codes}{tab:visibilitycodes}
+\begin{simplenametable}[1.5in]{Visibility codes}{tab:visibilitycodes}
\livetarg{chap:DWVISlocal}{DW\_VIS\_local} \\
\livetarg{chap:DWVISexported}{DW\_VIS\_exported} \\
\livetarg{chap:DWVISqualified}{DW\_VIS\_qualified} \\
\textit{The high PC value
may be beyond the last valid instruction in the executable.}
+\needlines{5}
The presence of low and high PC attributes for an entity
implies that the code generated for the entity is contiguous
and exists totally within the boundaries specified by those
\section{Entity Descriptions}
\textit{Some debugging information entries may describe entities
in the program that are artificial, or which otherwise are
-``named'' in ways which are not valid identifiers in the
+\doublequote{named} in ways which are not valid identifiers in the
programming language. For example, several languages may
capture or freeze the value of a variable at a particular
point in the program.
\addtoindex{Ada} 95 has package elaboration routines,
type descriptions of the form typename\textquoteright Class, and
-``access typename'' parameters. }
+\doublequote{access typename} parameters. }
Generally, any debugging information
entry that
for their work, while not being considered responsible for
modifications made by others.
-This License is a kind of \doublequote{copyleft}, which means that
+This License is a kind of \doublequote{copyleft,} which means that
derivative works of the document must themselves be free in
the same sense. It complements the GNU General Public License,
which is a copyleft license designed for free software.
holder saying it can be distributed under the terms of this
License. Such a notice grants a world-wide, royalty-free
license, unlimited in duration, to use that work under
-the conditions stated herein. The \doublequote{Document}, below,
+the conditions stated herein. The \doublequote{Document,} below,
refers to any such manual or work. Any member of the public
-is a licensee, and is addressed as \doublequote{you}. You accept the
+is a licensee, and is addressed as \doublequote{you.} You accept the
license if you copy, modify or distribute the work in a way
requiring permission under copyright law.
of markup, has been arranged to thwart or discourage subsequent
modification by readers is not Transparent. An image format is
not Transparent if used for any substantial amount of text. A
-copy that is not \doublequote{Transparent} is called \doublequote{Opaque}.
+copy that is not \doublequote{Transparent} is called \doublequote{Opaque.}
Examples of suitable formats for Transparent copies include
plain ASCII without markup, Texinfo input format, LaTeX
Document whose title either is precisely XYZ or contains
XYZ in parentheses following text that translates XYZ in
another language. (Here XYZ stands for a specific section
-name mentioned below, such as \doublequote{Acknowledgements},
-\doublequote{Dedications}, \doublequote{Endorsements}, or \doublequote{History}.) To
+name mentioned below, such as \doublequote{Acknowledgements,}
+\doublequote{Dedications,} \doublequote{Endorsements,} or \doublequote{History.}) To
\doublequote{Preserve the Title} of such a section when you modify
the Document means that it remains a section \doublequote{Entitled
XYZ} according to this definition.
\item Include an unaltered copy of this License.
-\item Preserve the section Entitled \doublequote{History}, Preserve
+\item Preserve the section Entitled \doublequote{History,} Preserve
its Title, and add to it an item stating at least the title,
year, new authors, and publisher of the Modified Version
as given on the Title Page. If there is no section Entitled
the Modified Version\textquoteright s license notice. These titles must
be distinct from any other section titles.
-You may add a section Entitled \doublequote{Endorsements}, provided
+You may add a section Entitled \doublequote{Endorsements,} provided
it contains nothing but endorsements of your Modified Version
by various parties\textemdash for example, statements of peer review
or that the text has been approved by an organization as the
to the section titles in the list of Invariant Sections in
the license notice of the combined work.
-In the combination, you must combine any sections Entitled
+In the combination, you must combine any sections entitled
\doublequote{History} in the various original documents, forming
-one section Entitled \doublequote{History}; likewise combine any
-sections Entitled \doublequote{Acknowledgements}, and any sections
-Entitled \doublequote{Dedications}. You must delete all sections
-Entitled \doublequote{Endorsements.}
+one section entitled \doublequote{History;} likewise combine any
+sections entitled \doublequote{Acknowledgements,} and any sections
+entitled \doublequote{Dedications.} You must delete all sections
+entitled \doublequote{Endorsements.}
\section{COLLECTIONS OF DOCUMENTS}
with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
Texts.
-A copy of the license is included in the section entitled ``GNU
-Free Documentation License''.
+A copy of the license is included in the section entitled \doublequote{GNU
+Free Documentation License.}
\end{myindentpara}
If you have Invariant Sections, Front-Cover Texts and
for a state machine and store a stream of bytes in the object
file instead of the matrix. This language can be much more
compact than the matrix. When a consumer of the line number
-information executes, it must ``run'' the state machine
+information executes, it must \doublequote{run} the state machine
to generate the matrix for each compilation unit it is
interested in. The concept of an encoded matrix also leaves
room for expansion. In the future, columns can be added to the
necessarily correspond to a specific source code
construct.} \\
+
sequence &
A series of contiguous target machine instructions. One compilation unit
may emit multiple sequences (that is, not all instructions within a
\subsection{State Machine Registers}
\label{chap:statemachineregisters}
-
The line number information state machine has the following
registers:
\begin{longtable}{l|p{9cm}}
- \caption{State Machine Registers } \\
+ \caption{State machine registers } \\
\hline \bfseries Register name&\bfseries Meaning\\ \hline
\endfirsthead
\bfseries Register name&\bfseries Meaning\\ \hline
\addttindex{column} &
An unsigned integer indicating a column number within a source line.
Columns are numbered beginning at 1. The value 0 is reserved to indicate
-that a statement begins at the ``left edge'' of the line. \\
+that a statement begins at the \doublequote{left edge} of the line. \\
\addttindex{is\_stmt} &
A boolean indicating that the current instruction is a recommended
to building line number information when machine instructions
are emitted in an order corresponding to the source program
is to set \addttindex{default\_is\_stmt}
-to ``true'' and to not change the
+to \doublequote{true} and to not change the
value of the \addttindex{is\_stmt} register
within the line number program.
One matrix entry is produced for each line that has code
opcodes in the line number program control which matrix entries
constitute such a recommendation and
\addttindex{default\_is\_stmt} might
-be either ``true'' or ``false''. This approach might be
+be either \doublequote{true} or \doublequote{false.} This approach might be
used as part of support for debugging optimized code.}
\item \texttt{line\_base} (\addtoindex{sbyte}) \\
that of the highest standard opcode and the first special
opcode (not inclusive) are used for vendor specific extensions.}
+\needlines{4}
\item \texttt{standard\_opcode\_lengths} (array of \addtoindex{ubyte}) \\
\addttindexx{standard\_opcode\_lengths}
This array specifies the number of \addtoindex{LEB128} operands for each
and sets the \addttindex{basic\_block},
\addttindex{prologue\_end} and
\addttindex{epilogue\_begin}
-registers to ``false.''
+registers to \doublequote{false.}
\item \textbf{DW\_LNS\_advance\_pc} \\
The \livetarg{chap:DWLNSadvancepc}{DW\_LNS\_advance\_pc}
operand and stores it in the \texttt{file} register
of the state machine.
+\needlines{4}
\item \textbf{DW\_LNS\_set\_column} \\
The \livetarg{chap:DWLNSsetcolumn}{DW\_LNS\_set\_column} opcode takes a
single unsigned LEB128\addtoindexx{LEB128!unsigned} operand
\addtoindexx{basic block}
takes no operands.
It sets the \addttindex{basic\_block} register of the
-state machine to ``true.''
+state machine to \doublequote{true.}
The \livetarg{chap:DWLNSsetprologueend}{DW\_LNS\_set\_prologue\_end}
opcode takes no operands. It sets the
\addttindex{prologue\_end} register
-to \doublequote{true}.
+to \doublequote{true.}
\textit{When a breakpoint is set on entry to a function, it is
generally desirable for execution to be suspended, not on the
\item \textbf{DW\_LNS\_set\_epilogue\_begin} \\
The \livetarg{chap:DWLNSsetepiloguebegin}{DW\_LNS\_set\_epilogue\_begin} opcode takes no operands. It
-sets the \addttindex{epilogue\_begin} register to \doublequote{true}.
+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
character should separate the right parenthesis that terminates
the formal parameter list and the following definition string.
-In the case of a ``normal'' (i.e. non-function-like) macro
+In the case of a \doublequote{normal} (i.e. non-function-like) macro
definition, exactly one space character should separate the
name of the defined macro from the following definition text.
by an asynchronous event (e.g. a signal).}
\item \textit{An area of memory that is allocated on a stack called a
-``call frame.'' The call frame is identified by an address
+\doublequote{call frame.} The call frame is identified by an address
on the stack. We refer to this address as the Canonical
Frame Address or CFA. Typically, the CFA is defined to be the
value of the stack pointer at the call site in the previous
\textit{To be able to view or modify an activation that is not
on the top of the call frame stack, the debugger must
-``virtually unwind'' the stack of activations until
+\doublequote{virtually unwind} the stack of activations until
it finds the activation of interest. A debugger unwinds
a stack in steps. Starting with the current activation it
virtually restores any registers that were preserved by the
on some machines with specific information that is defined by
an architecture specific ABI authoring committee, a hardware
vendor, or a compiler producer. The body defining a specific
-augmentation is referred to below as the ``augmenter.''
+augmentation is referred to below as the \doublequote{augmenter.}
Abstractly, this mechanism describes a very large table that
has the following structure:
section that denotes
the CIE that is associated with this FDE.
+\needlines{4}
\item \texttt{initial\_location} (segment selector and target address) \\
The
\addttindexx{initial\_location}
\textit{A normal compilation unit typically represents the text and
data contributed to an executable by a single relocatable
object file. It may be derived from several source files,
-including pre\dash processed \doublequote{include files}.
+including pre\dash processed \doublequote{include files.}
A \addtoindex{partial compilation unit} typically represents a part of the text
and data of a relocatable object file, in a manner that can
potentially be shared with the results of other compilations
-to save space. It may be derived from an \doublequote{include file},
+to save space. It may be derived from an \doublequote{include file,}
template instantiation, or other implementation\dash dependent
portion of a compilation. A normal compilation unit can also
function in a manner similar to a partial compilation unit
information for this compilation unit
(see Section \refersec{chap:linenumberinformation}).
+\needlines{6}
\item A \livelink{chap:DWATmacroinfo}{DW\_AT\_macro\_info} attribute
\addtoindexx{macro information attribute}
whose value is a
program but that a case insensitive lookup should be used to
access those names.
+\needlines{5}
\item A \livelink{chap:DWATbasetypes}{DW\_AT\_base\_types} attribute whose value is a
\livelink{chap:classreference}{reference}.
-
This
\hypertarget{chap:DWATbasetypesprimitivedatatypesofcompilationunit}
attribute
\subsection{Module Entries}
\label{chap:moduleentries}
-\textit{Several languages have the concept of a ``module.''
+\textit{Several languages have the concept of a \doublequote{module.}
\addtoindexx{Modula-2}
A Modula\dash 2 definition module
\addtoindexx{Modula-2!definition module}
namespace
\addtoindexx{namespace (C++)!global}
referred to by
-``::f'', for example) is not explicitly represented in
+\texttt{::f}, for example) is not explicitly represented in
DWARF with a namespace entry (thus mirroring the situation
in \addtoindex{C++} source).
Global items may be simply declared with no
reference to a namespace.}
\textit{The \addtoindex{C++}
-compilation unit specific ``unnamed namespace'' may
+compilation unit specific \doublequote{unnamed namespace} may
\addtoindexx{namespace (C++)!unnamed}
\addtoindexx{unnamed namespace|see {namespace (C++), unnamed}}
be represented by a namespace entry with no name attribute in
imported declaration entry has no name attribute but it does
have an import attribute that refers to the entry for the
entity being imported. (\addtoindex{C++}
-provides no means to ``rename''
+provides no means to \doublequote{rename}
an imported entity, other than a namespace).
}
\textit{A \addtoindex{Fortran} use statement
\addtoindexx{Fortran!use statement}
\addtoindexx{use statement|see {Fortran, use statement}}
-with an ``only list'' may be
+with an \doublequote{only list} may be
represented by a series of imported declaration entries,
one (or more) for each entity that is imported. An entity
\addtoindexx{renamed declaration|see{imported declaration entry}}
If this attribute is not present, or its value is the constant
\livetarg{chap:DWCCnormal}{DW\_CC\_normal}, then the subroutine may be safely called by
-obeying the ``standard'' calling conventions of the target
+obeying the \doublequote{standard} calling conventions of the target
architecture. If the value of the calling convention attribute
is the constant \livetarg{chap:DWCCnocall}{DW\_CC\_nocall}, the subroutine does not obey
standard calling conventions, and it may not be safe for the
If the semantics of the language of the compilation unit
containing the subroutine entry distinguishes between ordinary
-subroutines and subroutines that can serve as the ``main
-program,'' that is, subroutines that cannot be called
+subroutines and subroutines that can serve as the \doublequote{main
+program,} that is, subroutines that cannot be called
directly according to the ordinary calling conventions,
then the debugging information entry for such a subroutine
may have a calling convention attribute whose value is the
\livelink{chap:DWATelemental}{DW\_AT\_elemental} attribute, which
is a \livelink{chap:classflag}{flag}.
The attribute indicates whether the subroutine
-or entry point was declared with the ``elemental'' keyword
+or entry point was declared with the \doublequote{elemental} keyword
or property.
A
\livelink{chap:DWATpure}{DW\_AT\_pure} attribute, which is
a \livelink{chap:classflag}{flag}.
The attribute indicates whether the subroutine was
-declared with the ``pure'' keyword or property.
+declared with the \doublequote{pure} keyword or property.
A
\hypertarget{chap:DWATrecursiverecursivepropertyofasubroutine}
\livelink{chap:DWATrecursive}{DW\_AT\_recursive} attribute, which
is a \livelink{chap:classflag}{flag}.
The attribute indicates whether the subroutine
-or entry point was declared with the ``recursive'' keyword
+or entry point was declared with the \doublequote{recursive} keyword
or property.
list, while all variables\textquoteright\ location descriptions can be
simpler ones involving the frame base.}
-\item \textit{It can be used in resolving ``up\dash level'' addressing
+\item \textit{It can be used in resolving \doublequote{up\dash level} addressing
within nested routines.
(See also \livelink{chap:DWATstaticlink}{DW\_AT\_static\_link}, below)}
%The -See also- here is ok, the DW\_AT should be
that contains the
\livelink{chap:DWATinline}{DW\_AT\_inline} attribute is referred to
\addtoindexx{abstract instance!entry}
-as an ``abstract instance entry.''
+as an \doublequote{abstract instance entry.}
Any subroutine entry
that contains
\addtoindexx{inline attribute}
than \livelink{chap:DWINLnotinlined}{DW\_INL\_not\_inlined}
is known as
\addtoindexx{abstract instance!root}
-an ``abstract instance root.''
+an \doublequote{abstract instance root.}
Any set of abstract instance entries that are all
children (either directly or indirectly) of some abstract
instance root, together with the root itself, is known as
\addtoindexx{abstract instance!tree}
-an ``abstract instance tree.'' However, in the case where
+an \doublequote{abstract instance tree.} However, in the case where
an abstract instance tree is nested within another abstract
instance tree, the entries in the
\addtoindex{nested abstract instance}
Any debugging information entry that is owned (either
directly or indirectly) by a debugging information entry
with the tag \livelink{chap:DWTAGinlinedsubroutine}{DW\_TAG\_inlined\_subroutine} is referred to as a
-``concrete inlined instance entry.'' Any entry that has
+\doublequote{concrete inlined instance entry.} Any entry that has
the tag
\livelink{chap:DWTAGinlinedsubroutine}{DW\_TAG\_inlined\_subroutine}
-is known as a ``concrete inlined instance root.''
+is known as a \doublequote{concrete inlined instance root.}
Any set of concrete inlined instance
entries that are all children (either directly or indirectly)
of some concrete inlined instance root, together with the root
-itself, is known as a ``concrete inlined instance tree.''
+itself, is known as a \doublequote{concrete inlined instance tree.}
However, in the case where a concrete inlined instance tree
is nested within another concrete instance tree, the entries
in the \addtoindex{nested concrete inline instance} tree
executable instances of inlined subroutines other than at
points where those subroutines are actually called. Such
concrete instances of inlined subroutines are referred to as
-``concrete out\dash of\dash line instances.''
+\doublequote{concrete out\dash of\dash line instances.}
\textit{In \addtoindex{C++}, for example,
taking the address of a function declared
\section{Label Entries}
\label{chap:labelentries}
\textit{A label is a way of identifying a source statement. A labeled
-statement is usually the target of one or more ``go to''
+statement is usually the target of one or more \doublequote{go to}
statements.
}
\textit{Both \addtoindex{Pascal} and
\addtoindexx{Modula-2}
-Modula\dash 2 support the concept of a ``with''
+Modula\dash 2 support the concept of a \doublequote{with}
statement. The with statement specifies a sequence of
executable statements within which the fields of a record
variable may be referenced, unqualified by the name of the
\label{chap:tryandcatchblockentries}
\textit{In \addtoindex{C++} a lexical \livelink{chap:lexicalblock}{block} may be
-designated as a ``catch \nolink{block}.''
+designated as a \doublequote{catch \nolink{block}.}
A catch \livetargi{chap:catchblock}{block}{catch block} is an
exception handler that handles
exceptions thrown by an immediately
-preceding ``try \livelink{chap:tryblock}{block}.''
+preceding \doublequote{try \livelink{chap:tryblock}{block}.}
A catch \livelink{chap:catchblock}{block}
designates the type of the exception that it
can handle.}
Notes:
\begin{itemize}
-\item ``V2'' means \addtoindex{DWARF Version 2}, published July 1993.
-\item ``V3'' means \addtoindex{DWARF Version 3}, published December 2005.
-\item ``V4'' means \addtoindex{DWARF Version 4}, published June 2010.
-\item ``-'' means that a version number is not applicable
+\item \doublequote{V2} means \addtoindex{DWARF Version 2}, published July 1993.
+\item \doublequote{V3} means \addtoindex{DWARF Version 3}, published December 2005.
+\item \doublequote{V4} means \addtoindex{DWARF Version 4}, published June 2010.
+\item \doublequote{-} means that a version number is not applicable
(the section's header does not include a version).
-\item ``x'' means that the section was not defined in that
+\item \doublequote{x} means that the section was not defined in that
version of the DWARF standard.
\item The version numbers for the \dotdebuginfo{} and \dotdebugtypes{}
either a \livelink{chap:DWATbytesize}{DW\_AT\_byte\_size} attribute
\hypertarget{chap:DWATbitsizebasetypebitsize}
or a \livelink{chap:DWATbitsize}{DW\_AT\_bit\_size} attribute
-\addtoindex{bit size attribute}
+\addtoindexx{bit size attribute}
whose \livelink{chap:classconstant}{integer constant} value
(see Section \refersec{chap:byteandbitsizes})
is the amount of storage needed to hold
\needlines{5}
\textit{For example, the
-\addtoindex{C} type int on a machine that uses 32\dash bit
+\addtoindex{C} type \texttt{int} on a machine that uses 32\dash bit
integers is represented by a base type entry with a name
attribute whose value is \doublequote{int}, an encoding attribute
whose value is \livelink{chap:DWATEsigned}{DW\_ATE\_signed}
\addtoindexx{decimal sign attribute}
is an \livelink{chap:classconstant}{integer constant} that
conveys the representation of the sign of the decimal type
-(see Figure \refersec{tab:decimalsignattributevalues}).
+(see Table \refersec{tab:decimalsignattributevalues}).
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,
\livetarg{chap:DWDStrailingoverpunch}{DW\_DS\_trailing\_overpunch} & Sign
is encoded in the least significant digit in a target\dash dependent manner \\
\livetarg{chap:DWDSleadingseparate}{DW\_DS\_leading\_separate}
-& Decimal type: Sign is a ``+'' or ``-'' character
+& Decimal type: Sign is a \doublequote{+} or \doublequote{-} character
to the left of the most significant digit. \\
\livetarg{chap:DWDStrailingseparate}{DW\_DS\_trailing\_separate}
-& Decimal type: Sign is a ``+'' or ``-'' character
+& Decimal type: Sign is a \doublequote{+} or \doublequote{-} character
to the right of the least significant digit. \\
&Packed decimal type: Least significant nibble contains
a target\dash dependent value
\hypertarget{chap:DWATpicturestringpicturestringfornumericstringtype}
type is used to represent an edited
numeric or alphanumeric data type. It is used in combination
-with an \livelink{chap:DWATpicturestring}{DW\_AT\_picture\_string} attribute whose value is a
+with a \livelink{chap:DWATpicturestring}{DW\_AT\_picture\_string} attribute whose value is a
null\dash terminated string containing the target\dash dependent picture
string associated with the type.
entry for the type.
\textit{The \livelink{chap:DWATsmall}{DW\_AT\_small} attribute
-is defined with the \addtoindex{Ada} small
+is defined with the \addtoindex{Ada} \texttt{small}
attribute in mind.}
\section{Unspecified Type Entries}
entry with the name \doublequote{void} which can be referenced by the
type attribute of pointer types and typedef declarations for
'void' (see
-% FIXME: the following reference was wrong in DW4 so DavidA guessed
-% the intent.
-Sections \refersec{chap:unspecifiedtypeentries} and
+Sections \refersec{chap:typemodifierentries} and
%The following reference was valid, so the following is probably correct.
Section \refersec{chap:typedefentries},
respectively). As another
attribute to describe how objects having the given pointer
or reference type ought to be dereferenced.
-A modified type entry describing a shared qualified type
+A modified type entry describing a \addtoindex{UPC} shared qualified type
(using \livelink{chap:DWTAGsharedtype}{DW\_TAG\_shared\_type}) may have a
\livelink{chap:DWATcount}{DW\_AT\_count} attribute
\addtoindexx{count attribute}
\livetarg{chap:DWTAGsharedtype}{DW\_TAG\_shared\_type}&\addtoindex{UPC} shared qualified type
\addtoindexx{shared qualified type entry} \\
\livetarg{chap:DWTAGvolatiletype}{DW\_TAG\_volatile\_type}&C or C++ volatile qualified type
-\addtoindex{volatile qualified type entry} \\
+\addtoindexx{volatile qualified type entry} \\
\hline
\end{tabular}
\end{table}
\section{Array Type Entries}
\label{chap:arraytypeentries}
-\textit{Many languages share the concept of an ``array,'' which is
+\textit{Many languages share the concept of an \doublequote{array,} which is
\addtoindexx{array type entry}
a table of components of identical type.}
the dimensions in the source program (i.e., leftmost dimension
first, next to leftmost second, and so on).
-\textit{In languages, such as C, in which there is no concept of
-a \doublequote{multidimensional array}, an array of arrays may
+\textit{In languages that have no concept of a
+\doublequote{multidimensional array} (for example,
+\addtoindex{C}), an array of arrays may
be represented by a debugging information entry for a
multidimensional array.}
Section \refersec{chap:dynamictypeproperties}.
For relevant examples, see also Appendix \refersec{app:fortran90example}.
-\section{ Structure, Union, Class and Interface Type Entries}
+\section{Structure, Union, Class and Interface Type Entries}
\label{chap:structureunionclassandinterfacetypeentries}
\textit{The languages
\textit{\addtoindex{Pascal} and
other languages have a \doublequote{discriminated union,}
-\addtoindex{discriminated union|see {variant entry}}
+\addtoindexx{discriminated union|see {variant entry}}
also called a \doublequote{variant record.} Here, selection of a
number of alternative substructures (\doublequote{variants}) is based
on the value of a component that is not part of any of those
substructures (the \doublequote{discriminant}).}
\textit{\addtoindex{C++} and
-\addtoindex{Java} have the notion of ``class'', which is in some
+\addtoindex{Java} have the notion of \doublequote{class,} which is in some
ways similar to a structure. A class may have \doublequote{member
functions} which are subroutines that are within the scope
of a class or structure.}
attribute.
If a structure, union or class entry represents the definition
-of a structure, class or union member corresponding to a prior
-incomplete structure, class or union, the entry may have a
+of a structure, union or class member corresponding to a prior
+incomplete structure, union or class, the entry may have a
\livelink{chap:DWATspecification}{DW\_AT\_specification} attribute
\addtoindexx{specification attribute}
whose value is a \livelink{chap:classreference}{reference} to
information provided by the declaration entry referenced by the
specification attribute. In particular, such entries do not
need to contain an attribute for the name of the structure,
-class or union they represent if such information is already
+union or class they represent if such information is already
provided in the declaration.
\textit{For \addtoindex{C} and \addtoindex{C++},
\subsection{Interface Type Entries}
\label{chap:interfacetypeentries}
-\textit{The \addtoindex{Java} language defines ``interface'' types.
+\textit{The \addtoindex{Java} language defines \doublequote{interface} types.
An interface
-\addtoindex{interface type entry}
+\addtoindexx{interface type entry}
in \addtoindex{Java} is similar to a \addtoindex{C++} or
\addtoindex{Java} class with only abstract
methods and constant data members.}
\textit{In \addtoindex{C++}, a class (or struct)
may
\addtoindexx{derived type (C++)|see{inheritance entry}}
-be ``derived from'' or be a
-``subclass of'' another class.
-In \addtoindex{Java}, an interface may ``extend''
+be \doublequote{derived from} or be a
+\doublequote{subclass of} another class.
+In \addtoindex{Java}, an interface may \doublequote{extend}
\addtoindexx{extended type (Java)|see{inheritance entry}}
one
\addtoindexx{implementing type (Java)|see{inheritance entry}}
-or more other interfaces, and a class may ``extend'' another
-class and/or ``implement'' one or more interfaces. All of these
+or more other interfaces, and a class may \doublequote{extend} another
+class and/or \doublequote{implement} one or more interfaces. All of these
relationships may be described using the following. Note that
in \addtoindex{Java},
the distinction between extends and implements is
\livelink{chap:DWATdatamemberlocation}{DW\_AT\_data\_member\_location}
attribute, whose value describes the location of the beginning
of the inherited type relative to the beginning address of the
-derived class. If that value is a constant, it is the offset
+instance of the derived class. If that value is a constant, it is the offset
in bytes from the beginning of the class to the beginning of
-the inherited type. Otherwise, the value must be a location
+the instance of the inherited type. Otherwise, the value must be a location
description. In this latter case, the beginning address of
-the derived class is pushed on the expression stack before
+the instance of the derived class is pushed on the expression stack before
the \addtoindex{location description}
is evaluated and the result of the
-evaluation is the location of the inherited type.
+evaluation is the location of the instance of the inherited type.
\textit{The interpretation of the value of this attribute for
inherited types is the same as the interpretation for data
\subsection{Friends}
\label{chap:friends}
-Each ``friend''
+Each \doublequote{friend}
\addtoindexx{friend entry}
declared by a structure, union or class
\hypertarget{chap:DWATfriendfriendrelationship}
is not needed at the
beginning of a \addtoindex{location description} for a data member.
The
-result of the evaluation is a location--either an address or
+result of the evaluation is a location---either an address or
the name of a register, not an offset to the member.}
\textit{A \livelink{chap:DWATdatamemberlocation}{DW\_AT\_data\_member\_location}
the right.}
\begin{figure}[h]
+\begin{dwflisting}
\begin{verbatim}
+
j:0
k:5
m:11
| j | k | m | n | <pad> |
| | | | | |
+---------------------------------------------------------------+
+
\end{verbatim}
+\end{dwflisting}
\caption{Big-endian data bit offsets}
\label{fig:bigendiandatabitoffsets}
\end{figure}
\begin{figure}[h]
+\begin{dwflisting}
\begin{verbatim}
+
j:0
k:5
m:11
n:16
<- Addresses increase
- | A | A + 1 | A + 2 | A + 3 |
+ | A + 3 | A + 2 | A + 1 | A |
<- Data bit offsets increase
+---------------+---------------+---------------+---------------+
| <pad> | n | m | k | j |
| | | | | |
+---------------------------------------------------------------+
+
\end{verbatim}
+\end{dwflisting}
\caption{Little-endian data bit offsets}
\label{fig:littleendiandatabitoffsets}
\end{figure}
\addtoindex{DWARF Version 3} Standard.}
\textit{In comparing
-DWARF Versions 3
+DWARF Versions 3 and 4,
\addtoindexx{DWARF Version 3}
-and
\addtoindexx{DWARF Version 4}
-4, note that DWARF V4
+note that DWARF V4
defines the following combinations of attributes:}
-
\begin{itemize}
\item \textit{either \livelink{chap:DWATdatamemberlocation}{DW\_AT\_data\_member\_location}
or
\livelink{chap:DWATdatabitoffset}{DW\_AT\_data\_bit\_offset}
(to specify the beginning of the data member)}
-
-% FIXME: the indentation of the following line is suspect.
+\end{itemize}
\textit{optionally together with}
-
+\begin{itemize}
\item \textit{either \livelink{chap:DWATbytesize}{DW\_AT\_byte\_size} or
\livelink{chap:DWATbitsize}{DW\_AT\_bit\_size} (to
specify the size of the data member)}
-
\end{itemize}
-
-\textit{DWARF V3 defines the following combinations}
-
+\textit{DWARF V3 defines the following combinations:}
\begin{itemize}
\item \textit{\livelink{chap:DWATdatamemberlocation}{DW\_AT\_data\_member\_location}
(to specify the beginning
of the data member, except this specification is only partial
in the case of a bit field) }
-
-% FIXME: the indentation of the following line is suspect.
+\end{itemize}
\textit{optionally together with}
-
+\begin{itemize}
\item \textit{\livelink{chap:DWATbytesize}{DW\_AT\_byte\_size},
\livelink{chap:DWATbitsize}{DW\_AT\_bit\_size} and
\livelink{chap:DWATbitoffset}{DW\_AT\_bit\_offset}
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,
-this for \addtoindex{C++} or self
+\texttt{this} for \addtoindex{C++} or \texttt{self}
for \addtoindex{Objective C}
and some other languages). That parameter
also has a \livelink{chap:DWATartificial}{DW\_AT\_artificial} attribute whose value is true.
attributes for the name or return type of the function member
whose definition they represent.
+\needlines{5}
\subsection{Class Template Instantiations}
\label{chap:classtemplateinstantiations}
target architecture.
\needlines{5}
-\item The class type entry and each of its child entries references
+\item The class type entry and each of its child entries reference
a \addtoindex{template type parameter entry} in any circumstance where the
source template definition references a formal parameterized
type.
Similarly, the class type entry and each of its child
-entries references a template value parameter entry in any
+entries reference a template value parameter entry in any
circumstance where the source template definition references
a formal parameterized value.
+\needlines{4}
\item If the compiler has generated a special compilation unit to
hold the
\addtoindexx{template instantiation!and special compilation unit}
\textit{COBOL has the notion of
\addtoindexx{level-88 condition, COBOL}
-a ``level\dash 88 condition'' that
+a \doublequote{level\dash 88 condition} that
associates a data item, called the conditional variable, with
a set of one or more constant values and/or value ranges.
-Semantically, the condition is \textquoteleft true\textquoteright if the conditional
+% Note: the {} after \textquoteright (twice) is necessary to assure a following space separator
+Semantically, the condition is \textquoteleft true\textquoteright{}
+if the conditional
variable's value matches any of the described constants,
-and the condition is \textquoteleft false\textquoteright otherwise.}
+and the condition is \textquoteleft false\textquoteright{} otherwise.}
The \livetarg{chap:DWTAGcondition}{DW\_TAG\_condition}
debugging information entry\addtoindexx{condition entry}
type of an array element if the parent has an array type;
otherwise it is the type of the parent entry.
+\needlines{4}
The condition entry owns \livelink{chap:DWTAGconstant}{DW\_TAG\_constant} and/or
\livelink{chap:DWTAGsubrangetype}{DW\_TAG\_subrange\_type} entries that describe the constant
values associated with the condition. If any child entry
which specifies the separation
between successive elements along the dimension as described
in
-Section \refersec{chap:visibilityofdeclarations}.
+Section \refersec{chap:staticanddynamicvaluesofattributes}.
The value of the
\livelink{chap:DWATbitstride}{DW\_AT\_bit\_stride} attribute
\addtoindexx{bit stride attribute}
it is possible to declare pointers to subroutines that not
only return a value of a specific type, but accept only
arguments of specific types. The type of such pointers would
-be described with a ``pointer to'' modifier applied to a
+be described with a \doublequote{pointer to} modifier applied to a
user\dash defined type.}
A subroutine type is represented by a debugging information
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
+type entry corresponds to either a formal parameter or the sequence of
unspecified parameters of the subprogram type:
\begin{enumerate}[1. ]
\section{String Type Entries}
\label{chap:classstringtypeentries}
-\textit{A ``string'' is a sequence of characters that have specific
+\textit{A \doublequote{string} is a sequence of characters that have specific
\addtoindexx{string type entry}
semantics and operations that separate them from arrays of
characters.
\addtoindex{Fortran} is one of the languages that has a string
-type. Note that ``string'' in this context refers to a target
+type. Note that \doublequote{string} in this context refers to a target
machine concept, not the class string as used in this document
(except for the name attribute).}
referenced by the string length attribute. If no (byte or bit)
size attribute is present, the size of the data to be retrieved
is the same as the
-\addtoindex{size of an address} on the target machine.
+\addtoindex{size of an address} on the target machine.Fif the amount
-\needlines{5}
+\needlines{4}
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}
a \livelink{chap:DWATtype}{DW\_AT\_type} attribute to denote the
type of an element of the set.
+\needlines{4}
If the amount of storage allocated to hold each element of an
object of the given set type is different from the amount of
storage that is normally allocated to hold an individual object
\section{Subrange Type Entries}
\label{chap:subrangetypeentries}
-\textit{Several languages support the concept of a ``subrange''
+\textit{Several languages support the concept of a \doublequote{subrange}
type object. These objects can represent a subset of the
values that an object of the basis type for the subrange can
represent.
describe the type of the class or structure member to which
objects of this type may point.
-The \addtoindex{pointer to member} entry also
+The \addtoindexx{pointer to member} entry also
\hypertarget{chap:DWATcontainingtypecontainingtypeofpointertomembertype}
has a
\livelink{chap:DWATcontainingtype}{DW\_AT\_containing\_type}
\begin{lstlisting}[numbers=none]
object.*mbr_ptr
\end{lstlisting}
-% FIXME: object and mbr\_ptr should be distinguished from italic. See DW4.
-\textit{where mbr\_ptr has some \addtoindex{pointer to member type}, a debugger should:}
-
-\textit{1. Push the value of mbr\_ptr onto the DWARF expression stack.}
-
-\textit{2. Push the base address of object onto the DWARF expression stack.}
+\textit{where \texttt{mbr\_ptr} has some \addtoindex{pointer to member type}, a debugger should:}
+\begin{enumerate}
+\item \textit{Push the value of \texttt{mbr\_ptr} onto the DWARF expression stack.}
+\item \textit{Push the base address of \texttt{object} onto the DWARF expression stack.}
+\item \textit{Evaluate the \livelink{chap:DWATuselocation}{DW\_AT\_use\_location} description
+given in the type of \texttt{mbr\_ptr}.}
+\end{enumerate}
-\textit{3. Evaluate the \livelink{chap:DWATuselocation}{DW\_AT\_use\_location} description
-given in the type of mbr\_ptr.}
\section{File Type Entries}
\label{chap:filetypeentries}
A file type is represented by a debugging information entry
with
\addtoindexx{file type entry}
-the
+the tag
\livetarg{chap:DWTAGfiletype}{DW\_TAG\_file\_type}.
If the file type has a name,
the file type entry has a \livelink{chap:DWATname}{DW\_AT\_name} attribute,
DWARF Git Projects / dwarf-doc.git / commitdiff