using an \addtoindex{imported unit entry}
(see Section \refersec{chap:importedunitentries}).}
-\textit{A
-combined split and partial
-compilation unit kind is not defined.}
+\bb
+\textit{A partial compilation unit is not defined for use
+within a split object file.}
+\eb
\textit{In the remainder of this document, the word
\doublequote{compilation} in the phrase \doublequote{compilation unit}
\DWTAGtypeunit{}
are used to represent portions of an object file.
+\needlines{4}
\textit{A full 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,
See Appendix \refersec{app:dwarfcompressionandduplicateeliminationinformative}
for discussion of related compression techniques.}
-A compilation unit entry owns debugging information
+\bb
+A full or partial
+\eb
+compilation unit entry owns debugging information
entries that represent all or part of the declarations
made in the corresponding compilation. In the case of a
partial compilation unit, the containing scope of its owned
partial compilation unit (see
Section \refersec{chap:importedunitentries}).
-Compilation unit entries may have the following
-attributes:
+\bb
+A full or partial compilation unit entry
+\eb
+may have the following attributes:
\begin{enumerate}[1. ]
\item Either a \DWATlowpc{} and
\DWAThighpc{} pair of
unit. The set of language names and their meanings are given
in Table \refersec{tab:languagenames}.
+\vspace{1cm}
+\needlines{8}
\begin{centering}
- \setlength{\extrarowheight}{0.1cm}
+\setlength{\extrarowheight}{0.1cm}
\begin{longtable}{l|l}
\caption{Language names} \label{tab:languagenames} \\
\hline \bfseries Language name & \bfseries Meaning \\ \hline
\addtoindexx{ISO-defined language names}
\DWLANGAdaeightythreeTARG{} \dag & ISO Ada:1983 \addtoindexx{Ada:1983 (ISO)} \\
\DWLANGAdaninetyfiveTARG{} \dag & ISO Ada:1995 \addtoindexx{Ada:1995 (ISO)} \\
-\DWLANGCTARG & Non-standardized C, such as K\&R \addtoindexx{C!non-standard}\\
-\DWLANGCeightynineTARG & ISO C:1989 \addtoindexx{C:1989 (ISO)} \\
-\DWLANGCninetynineTARG & ISO C:1999 \addtoindexx{C:1999 (ISO)} \\
-\DWLANGCelevenTARG & ISO C:2011 \addtoindexx{C:2011 (ISO)} \\
+\bb
+\DWLANGBLISSTARG & BLISS \addtoindexx{BLISS}
+\eb
+\\
+\DWLANGCTARG & Non-standardized C, such as K\&R \addtoindexx{C!non-standard} \\*
+\DWLANGCeightynineTARG & ISO C:1989 \addtoindexx{C:1989 (ISO)} \\*
+\DWLANGCninetynineTARG & ISO C:1999 \addtoindexx{C:1999 (ISO)} \\*
+\DWLANGCelevenTARG & ISO C:2011 \addtoindexx{C:2011 (ISO)} \\*
\DWLANGCplusplusTARG & ISO C++98 \addtoindexx{C++98 (ISO)} \\
\DWLANGCpluspluszerothreeTARG & ISO C++03 \addtoindexx{C++03 (ISO)} \\
\DWLANGCpluspluselevenTARG & ISO C++11 \addtoindexx{C++11 (ISO)} \\
\DWLANGPascaleightythreeTARG & ISO Pascal:1983 \addtoindexx{Pascal:1983 (ISO)} \\
\DWLANGPLITARG{}~\dag & ANSI PL/I:1976 \addtoindexx{PL/I:1976 (ANSI)} \\
\DWLANGPythonTARG{}~\dag & \addtoindex{Python} \\
+\DWLANGRenderScriptTARG~\dag &
+\bb
+\addtoindex{RenderScript Kernel Language}
+\eb
+\\
\DWLANGRustTARG{}~\dag & \addtoindex{Rust} \\
\DWLANGSwiftTARG{}
& \addtoindex{Swift} \\
\item \hypertarget{chap:DWATproducercompileridentification}{}
A \DWATproducerDEFN{} attribute\addtoindexx{producer attribute}
whose value is a null-terminated string containing
-information about the compiler
-that produced the compilation unit. The actual contents of
+information about the compiler that produced the compilation unit.
+
+\textit{The actual contents of
the string will be specific to each producer, but should
begin with the name of the compiler vendor or some other
-identifying character sequence that should avoid confusion
-with other producer values.
+identifying character sequence that will avoid confusion
+with other producer values.}
\needlines{4}
\item \hypertarget{chap:DWATidentifiercaseidentifiercaserule}{}
\addtoindexx{name attribute}
in debugging information
entries for the compilation unit reflect the names as they
-appear in the source program. The debugger should be sensitive
+appear in the source program.
+
+\textit{A debugger should be sensitive
to the case of \addtoindex{identifier names} when doing identifier
-lookups.
+lookups.}
\needlines{4}
\DWIDupcaseTARG{} means that the
producer of the debugging
information for this compilation unit converted all source
names to upper case. The values of the name attributes may not
-reflect the names as they appear in the source program. The
-debugger should convert all names to upper case when doing
-lookups.
+reflect the names as they appear in the source program.
+
+\textit{A debugger should convert all names to upper case
+when doing lookups.}
-\DWIDdowncaseTARG{} means that
-the producer of the debugging
+\DWIDdowncaseTARG{} means that the producer of the debugging
information for this compilation unit converted all source
names to lower case. The values of the name attributes may not
-reflect the names as they appear in the source program. The
-debugger should convert all names to lower case when doing
-lookups.
+reflect the names as they appear in the source program.
+
+\textit{A debugger should convert all names to lower case
+when doing lookups.}
\needlines{4}
\DWIDcaseinsensitiveTARG{} means that the values of the name
attributes reflect the names as they appear in the source
-program but that a case insensitive lookup should be used to
-access those names.
+program but that case is not significant.
+
+\textit{A debugger should ignore case when doing lookups.}
\needlines{5}
\item \hypertarget{chap:DWATbasetypesprimitivedatatypesofcompilationunit}{}
offset of the compilation unit's contribution to the
\dotdebugstroffsets{} (or \dotdebugstroffsetsdwo{}) section.
Indirect string references
-(using \DWFORMstrx) within the compilation unit are
+(using \DWFORMstrxXNor) within the compilation unit are
interpreted as indices relative to this base.
\needlines{6}
attribute, whose value is of class \CLASSaddrptr.
This attribute points to the beginning of the compilation
unit's contribution to the \dotdebugaddr{} section.
-Indirect references (using \DWFORMaddrx, \DWOPaddrx,
-\DWOPconstx, \DWLLEbaseaddressselectionentry{},
-\DWLLEstartendentry{} or \DWLLEstartlengthentry)
+Indirect references (using \DWFORMaddrxXN, \DWOPaddrx,
+\DWOPconstx,
+\bb
+\DWLLEbaseaddressx{}, \DWLLEstartxendx{}, \DWLLEstartxlength{},
+\DWRLEbaseaddressx{}, \DWRLEstartxendx{} or \DWRLEstartxlength)
+\eb
within the compilation unit are interpreted as indices
relative to this base.
\needlines{5}
-\item \hypertarget{chap:DWATrangesbaseforrangelists}{}
-A \DWATrangesbaseDEFN\addtoindexx{ranges table base attribute}
-attribute, whose value is of class \CLASSrangelistptr.
-This attribute points to the beginning of the compilation
-unit's contribution to the \dotdebugranges{} section.
-References to range lists (using \DWFORMsecoffset)
+\item \hypertarget{chap:DWATrnglistsbaseforrnglists}{}
+A \DWATrnglistsbaseDEFN\addtoindexx{ranges table base attribute}
+attribute, whose value is of class \CLASSrnglistsptr.
+This attribute points to the
+\bb
+beginning of the offsets table (immediately following the header)
+\eb
+of the compilation
+unit's contribution to the \dotdebugrnglists{} section.
+References to range lists (using \DWFORMrnglistx)
within the compilation unit are
-interpreted as offsets relative to this base.
+interpreted relative to this base.
+\item \hypertarget{chap:DWATloclistsbaseinlocationlist}{}
+A \DWATloclistsbaseDEFN{}\addtoindexx{location table base attribute}
+attribute, whose value is of class \CLASSloclistsptr.
+This attribute points to the
+\bb
+beginning of the offsets table (immediately following the header)
+\eb
+of the compilation
+unit's contribution to the \dotdebugloclists{} section. References
+to location lists (using \DWFORMloclistx) within the compilation
+unit are interpreted relative to this base.
\end{enumerate}
The base address of a compilation unit is defined as the
When generating a \splitDWARFobjectfile{} (see
Section \refersec{datarep:splitdwarfobjectfiles}), the
compilation unit in the \dotdebuginfo{} section is a "skeleton"
-compilation unit with the tag \DWTAGcompileunit, which contains
-\DWATdwoname{} and \DWATdwoid{} attributes as well as a subset of the
+compilation unit with the tag
+\DWTAGskeletonunitTARG, which contains a
+\DWATdwoname{} attribute as well as a subset of the
attributes of a full or partial compilation unit. In general,
it contains those attributes that are necessary for the consumer
to locate the object file where the split full compilation unit
A skeleton compilation unit has no children.
-A skeleton compilation unit has \DWATdwoname{} and
-\DWATdwoid{} attributes:
+A skeleton compilation unit has a \DWATdwoname{} attribute:
\begin{enumerate}[1. ]
see below) of the object file that contains the full
compilation unit.
-\item \livetarg{chap:DWATdwoidforunit}{}
-A \DWATdwoidDEFN{} attribute\addtoindexx{unit identification attribute}
-whose implementation-defined integer constant value,
-known as the \CUsignature,
-provides unique identification of this compilation unit
-as well as the associated split compilation unit in the
-object file named in the \DWATdwoname{}
-attribute. For simplicity, the \DWATdwoidNAME{} attributes
-in the skeleton compilation unit and the corresponding
-split full compilation unit
-(see Section \refersec{chap:splitfullcompilationunitentries})
-must use the same form to encode this identification value.
-
-\textit{The means of determining a \CUsignature{} does not
-need to be similar or related to the means of determining a
-\TUsignature.}
+The value in the \HFNdwoid{} field of the unit header for
+this unit is the same as the value in the \HFNdwoid{} field
+of the unit header of the corresponding full compilation
+unit (see Section \refersec{datarep:unitheaders}).
+
+\textit{The means of determining a compilation unit ID does
+not need to be similar or related to the means of
+determining a \TUsignature. However, it should
+be suitable for detecting file version skew or other
+kinds of mismatched files and for looking up a full
+split unit in a DWARF package file
+(see Section \refersec{datarep:dwarfpackagefiles}).}
\end{enumerate}
which are the same as for conventional compilation unit entries
except as noted, from among the following:
\begin{enumerate}[1. ]
-\addtocounter{enumi}{2}
+\addtocounter{enumi}{1}
\item Either a \DWATlowpc{} and \DWAThighpc{} pair of attributes
or a \DWATranges{} attribute.
\item A \DWATstmtlist{} attribute.
\item A \DWATstroffsetsbase{} attribute, for indirect strings references
from the skeleton compilation unit.
\item A \DWATaddrbase{} attribute.
-\item A \DWATrangesbase{} attribute.
\end{enumerate}
All other attributes of a compilation unit entry (described
-in Section \refersec{chap:fullandpartialcompilationunitentries})
-should be placed in the split full compilation unit
+in Section \refersec{chap:fullandpartialcompilationunitentries})
+are placed in the split full compilation unit
(see \refersec{chap:splitfullcompilationunitentries}).
The attributes provided by the skeleton compilation
unit entry do not need to be repeated in the full compilation
-unit entry, except for \DWATdwoid, which should appear in
-both entries so that the consumer can verify that it has
-found the correct object file.
+unit entry.
-\textit{The \DWATaddrbase{}, \DWATrangesbase{} and
-\DWATstroffsetsbase{} attributes provide context that may be
+\textit{The \DWATaddrbase{}
+and \DWATstroffsetsbase{} attributes provide context that may be
necessary to interpret the contents
of the corresponding \splitDWARFobjectfile.}
is logically paired with a specific skeleton compilation unit while
being physically separate.
-A split full compilation unit has a \DWATdwoid{} attribute:
-\begin{enumerate}[1. ]
-\item
-A \DWATdwoidDEFN{} attribute\addtoindexx{unit identification attribute}
-whose implementation-defined integer constant value,
-known as the \CUsignature,
-provides unique identification of this compilation unit
-as well as the associated skeleton compilation unit.
-For simplicity, the \DWATdwoidNAME{} attributes in the
-split compilation unit and the associated skeleton
-compilation unit must use the same form to encode the
-identification value.
-
-\end{enumerate}
-
-\needlines{4}
-A split full compilation unit may also have additional attributes,
+A split full compilation unit
+may have the following attributes,
which are the same as for conventional compilation unit entries
-except as noted, from among the following:
+except as noted:
\begin{enumerate}[1. ]
-\addtocounter{enumi}{1}
\item A \DWATname{} attribute.
\item A \DWATlanguage{} attribute.
\item A \DWATmacros{} attribute.
(if present) from the corresponding skeleton compilation unit:
\DWATlowpc, \DWAThighpc, \DWATranges, \DWATstmtlist, \DWATcompdir,
\DWATstroffsetsbase, \DWATaddrbase{} and
-\DWATrangesbase.}
+\DWATrnglistsbase.}
\textit{The \DWATbasetypes{} attribute is not defined for a
split full compilation unit.}
Moreover, the \DWATstroffsetsbase{} attribute (see below) is not
used in a split type unit.
+\needlines{4}
A type unit is represented by a debugging information entry
with the tag \DWTAGtypeunitTARG.
A \addtoindex{type unit entry} owns debugging
\addtoindex{specialized line number table},
are represented using the UTF-8 representation.
-\item A
-\DWATstroffsetsbase\addtoindexx{string offsets base attribute}
+\needlines{4}
+\item A \DWATstroffsetsbase\addtoindexx{string offsets base attribute}
attribute, whose value is of class \CLASSstroffsetsptr.
This attribute points
to the first string offset of the type unit's contribution to
the \dotdebugstroffsets{} section. Indirect string references
-(using \DWFORMstrx) within the type unit are interpreted
+(using \DWFORMstrxXNor) within the type unit are interpreted
as indices relative to this base.
\end{enumerate}
within debugging information entries describing its containers;
otherwise, T is a direct child of the type unit entry.
+\needlines{4}
A type unit entry may also own additional debugging information
entries that represent declarations of additional types that
are referenced by type T and have not themselves been placed in
entities into a single entity and to manage the names of
those entities.}
+\needlines{8}
\subsection{Module Entries}
\label{chap:moduleentries}
\textit{Several languages have the concept of a \doublequote{module.}
whose value is a null\dash terminated string containing
the module name.
+\needlines{4}
The \addtoindex{module entry} may have either a
\DWATlowpc{} and
\DWAThighpc{}
be represented by a namespace entry with no name attribute in
the original namespace declaration entry (and therefore no name
attribute in any namespace extension entry of this namespace).
-}
+C++ states that declarations in the unnamed namespace are
+implicitly available in the containing scope; a producer
+should make this effect explicit with the \DWATexportsymbols{}
+attribute, or by using a \DWTAGimportedmodule{} that is a
+sibling of the namespace entry and references it.}
\textit{A compiler emitting namespace information may choose to
explicitly represent namespace extensions, or to represent the
in a different module or scope. An imported declaration may
sometimes be given another name.}
+\needlines{6}
An imported declaration is represented by one or
\addtoindexx{imported declaration entry}
more debugging information entries with the
in Section \refersec{chap:importedorrenameddeclarationentries}.
}
-\needlines{5}
+\needlines{8}
\textit{A \addtoindex{Fortran} use statement for an entity in a module that is
\addtoindexx{Fortran!use statement}
itself imported by a use statement without an explicit mention
may be represented by an imported declaration entry that refers
-to the original debugging information entry. For example, given
-}
+to the original debugging information entry. For example, given}
+\par % Needed to end paragraph before listing so that it gets a line number
\vspace{2mm}
-\begin{lstlisting}
+\begin{nlnlisting}
module A
integer X, Y, Z
end module
use B, only Q => X
end module
-\end{lstlisting}
+\end{nlnlisting}
\textit{the imported declaration entry for Q within module C refers
directly to the variable declaration entry for X in module A
because there is no explicit representation for X in module B.
\addtoindexx{entry point entry}
points:
+\nolinenumbers
\begin{tabular}{lp{9.0cm}}
\DWTAGsubprogramTARG{} & A subroutine or function \\
\DWTAGinlinedsubroutine{} & A particular inlined
instance of a subroutine or function \\
\DWTAGentrypointTARG{} & An alternate entry point \\
\end{tabular}
-
+\par\condlinenumbers
\needlines{6}
\subsection{General Subroutine and Entry Point Information}
indicates whether the subprogram was declared with the \doublequote{noreturn} keyword or property
indicating that the subprogram can be called, but will never return to its caller.
+\needlines{4}
\textit{The \addtoindex{Fortran}
language allows the keywords \texttt{elemental}, \texttt{pure}
and \texttt{recursive} to be included as part of the declaration of
\textit{The \DWATcallallsourcecallsNAME{} attribute is intended for debugging
information format consumers that analyze call graphs.}
+\needlines{4}
If the the \DWATcallallsourcecalls{} attribute is present then the
\DWATcallallcalls{} and \DWATcallalltailcalls{} attributes are
also implicitly present. Similarly, if the
subroutine or entry point.
In the context of supporting nested subroutines, the
-\DWATframebase{} attribute value should obey the following
-constraints:
+\DWATframebase{} attribute value obeys the following constraints:
\begin{enumerate}[1. ]
-\item It should compute a value that does not change during the
+\item
+It computes a value that does not change during the
life of the subprogram, and
-\item The computed value should be unique among instances of
-the same subroutine. (For typical \DWATframebase{} use, this
+\item The computed value is unique among instances of
+the same subroutine.
+
+\textit{For typical \DWATframebase{} use, this
means that a recursive subroutine\textquoteright s stack frame must have
-non-zero size.)
+non-zero size.}
+
\end{enumerate}
\textit{If a debugger is attempting to resolve an up\dash level reference
set of values for the \DWATinline{} attribute is given in
Table \refersec{tab:inlinecodes}.
-\begin{table}[h]
+\begin{table}[ht]
\centering
\caption{Inline codes}
\label{tab:inlinecodes}
tree are not considered to be entries in the outer abstract
instance tree.
+\needlines{6}
Each abstract instance root is either part of a larger
\addtoindexx{abstract instance!root}
tree (which gives a context for the root) or
by all concrete instances (see Section \refersec{chap:concreteinstances}).
A debugging information entry that is a member of an abstract
-instance tree should not contain any attributes which describe
+instance tree may not contain any attributes which describe
aspects of the subroutine which vary between distinct inlined
-expansions or distinct out-of-line expansions. For example,
+expansions or distinct out-of-line expansions.
+
+\textit{For example,
\addtoindexx{entry pc attribute!and abstract instance}
-the \DWATlowpc,
-\DWAThighpc,
-\DWATranges,
-\DWATentrypc,
-\DWATlocation,
-\DWATreturnaddr,
-\DWATstartscope,
+the \DWATlowpc,\addtoindexx{low PC attribute!and abstract instance}
+\DWAThighpc,\addtoindexx{high PC attribute!and abstract instance}
+\DWATranges,\addtoindexx{ranges attribute!and abstract instance}
+\DWATentrypc,\addtoindexx{entry PC attribute!and abstract instance}
+\DWATlocation,\addtoindexx{location attribute!and abstract instance}
+\DWATreturnaddr,\addtoindexx{return address attribute!and abstract instance}
+\DWATstartscope,\addtoindexx{start scope attribute!and abstract instance}
and
-\DWATsegment{}
-attributes
-\addtoindexx{location attribute!and abstract instance}
-typically
-\addtoindexx{ranges attribute!and abstract instance}
-should
-\addtoindexx{high PC attribute!and abstract instance}
-be
-\addtoindexx{low PC attribute!and abstract instance}
-omitted;
-\addtoindexx{segment attribute!and abstract instance}
-however,
-\addtoindexx{return address attribute!and abstract instance}
-this
-\addtoindexx{segment attribute!and abstract instance}
-list
-\addtoindexx{start scope attribute!and abstract instance}
-is not exhaustive.
+\DWATsegment{}\addtoindexx{segment attribute!and abstract instance}
+attributes typically should be omitted; however, this list is not
+exhaustive.}
\needlines{5}
\textit{It would not make sense normally to put these attributes into
Each inline expansion of a subroutine is represented
by a debugging information entry with the
-tag \DWTAGinlinedsubroutineTARG.
-Each such entry should be a direct
+tag \DWTAGinlinedsubroutineTARG. Each such entry is a direct
child of the entry that represents the scope within which
the inlining occurs.
as well as a \DWATconstvalue{} attribute whose value represents
the actual return value of the concrete inlined instance.}
+\needlines{4}
Any debugging information entry that is owned (either
directly or indirectly) by a debugging information entry
with the tag \DWTAGinlinedsubroutine{} is referred to as a
attributes describing the
\addtoindexx{declaration coordinates!in concrete instance}
\livelink{chap:declarationcoordinates}{declaration coordinates}
-of that entry, then those attributes should refer to the file, line
+of that entry, then those attributes 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
entry within a concrete inlined instance tree needs to refer
to an entity declared within the scope of the relevant inlined
subroutine and for which no concrete instance entry exists,
-the reference should refer to the abstract instance entry.
+the reference refers to the abstract instance entry.
\needlines{4}
\item Entries in the concrete instance tree which are associated
not correspond to entries in the abstract instance tree
to describe new entities that are specific to a particular
inlined expansion. In that case, they will not have associated
-entries in the abstract instance tree, should not contain
+entries in the abstract instance tree, do not contain
\addtoindexx{abstract origin attribute}
\DWATabstractorigin{} attributes, and must contain all their
own attributes directly. This allows an abstract instance tree
breakpoint in the target subroutine instead. This helps to
hide the compiler generated subprogram from the user. }
-\bb
\section{Call Site Entries and Parameters}
-\eb
\label{chap:callsiteentriesandparameters}
-\bb
\textit{
A call site entry describes a call from one subprogram to another in the
source program. It provides information about the actual parameters of
registers and memory locations might have been modified. In order to
recover the values that existed at the point of the call (to allow
evaluation of the DWARF expression for the actual parameter), a debugger
-may "virtually unwind" the subprogram activation
+may virtually unwind the subprogram activation
(see Section \refersec{chap:callframeinformation}). Any
register or memory location that cannot be recovered is referred to as
"clobbered by the call."}
-\eb
-
-\bbpareb
A source call can be compiled into different types of machine code:
\begin{itemize}
\item
A \textit{normal call} uses a call-like instruction which transfers
control to the start of some subprogram and preserves the call site
-\bb
location for use by the callee.
-\eb
+
\item
A \textit{tail call} uses a jump-like instruction which
transfers control to the start of some subprogram, but
-\bb
there is no call site location address to preserve
-(and thus none is available using the unwind information).
-\eb
+(and thus none is available using the
+virtual unwind information).
+
\item
A \textit{tail recursion call} is a call
to the current subroutine which is compiled as a jump
to the current subroutine.
+
\needlines{4}
\item
An \textit{inline (or inlined) call} is a call to an inlined subprogram,
\DWTAGcallsite{} entries describe normal and tail calls but not tail recursion calls,
while \DWTAGinlinedsubroutine{} entries describe inlined calls
(see Section \refersec{chap:inlinedsubroutines}).
-\bb
Call site entries cannot describe tail recursion or optimized out calls.
-\eb
-\bb
\subsection{Call Site Entries}
\label{chap:callsiteentries}
A call site is represented by a debugging information entry with the tag
otherwise be present in the debugging information of a subroutine
need not be introduced solely to represent the immediately containing scope
of a call.}
-\eb
The call site entry may have a
\DWATcallreturnpcDEFN{}\addtoindexx{call site return pc attribute}
The call site entry may have a
\DWATcallpcDEFN{}\addtoindexx{call pc attribute}
-\livetargi{chap:DWATcallpcofcallsite}{attribute}{call pc attribute} which is the
-address of the
-\bb
+\livetargi{chap:DWATcallpcofcallsite}{attribute}{call pc attribute}
+which is the address of the
call-like instruction for a normal call or the jump-like
instruction for a tail call.
-\eb
If the call site entry corresponds to a tail call, it has the
\DWATcalltailcallDEFN{}\addtoindexx{call tail call attribute}
\livetargi{chap:DWATcalltargetofcallsite}{attribute}{call target attribute} which is
a DWARF expression. For indirect calls or jumps where it is unknown at
compile time which subprogram will be called the expression computes the
-address of the subprogram that will be called. The DWARF expression should
-not use register or memory locations that might be clobbered by the call.
+address of the subprogram that will be called.
+
+\textit{The DWARF expression should
+not use register or memory locations that might be clobbered by the call.}
\needlines{4}
The call site entry may have a
line, and declaration column attributes, respectively
(see Section \refersec{chap:declarationcoordinates}).
-\textit{The call file, call line and call column coordinates do not describe the
-coordinates of the subroutine declaration that was called, rather they describe
-the coordinates of the call.}
+\textit{The call file, call line and call column coordinates do
+not describe the coordinates of the subroutine declaration that
+was called, rather they describe the coordinates of the call.}
\needlines{5}
-\bb
\subsection{Call Site Parameters}
-\eb
\label{chap:callsiteparameters}
The call site entry may own
\DWTAGcallsiteparameterTARG{}\index{call site parameter entry}
-debugging information entries representing the parameters passed to the call.
-\bb
-Call site parameter entries occur in the same order as the corresponding
-parameters in the source.
-\eb
+debugging information entries representing the parameters passed
+to the call.
+Call site parameter entries occur in the same order as the
+corresponding parameters in the source.
Each such entry has a \DWATlocation{} attribute which is a location
-\bb
-description.
-\eb
-This location
-\bb
-description
-\eb
+description. This location description
describes where the parameter is passed
-(usually either some register, or a memory location expressible as the
-contents of the stack register plus some offset).
+(usually either some register, or a memory location expressible as
+the contents of the stack register plus some offset).
\needlines{4}
Each \DWTAGcallsiteparameter{} entry may have a
which is a DWARF expression
which when evaluated yields the value of the parameter at the time of the call.
-\textit{The expression should not use registers or memory
-locations that might be clobbered by the call, as it might be evaluated after
-unwinding from the called function back to the caller. If it is not
+\textit{If it is not
possible to avoid registers or memory locations that might be clobbered by
the call in the expression, then the \DWATcallvalueNAME{} attribute should
-not be provided.}
-
-\textit{The reason for the restriction is that the value of the parameter may be
+not be provided. The reason for the restriction is that the value of the parameter may be
needed in the midst of the callee, where the call clobbered registers or
memory might be already clobbered, and if the consumer is not assured by
the producer it can safely use those values, the consumer can not safely
For parameters passed by reference, where the code passes a pointer to
a location which contains the parameter, or for reference type parameters,
the \DWTAGcallsiteparameter{} entry may also have a
-\bb
\DWATcalldatalocationDEFN{}\addtoindexx{call data location attribute}
-\eb
\livetargi{chap:DWATcalldatalocationofcallparameter}{attribute}{call data location attribute}
-whose value is a location
-\bb
-description
-\eb
-and a
-\bb
+whose value is a location description and a
\DWATcalldatavalueDEFN{}\addtoindexx{call data value attribute}
-\eb
\livetargi{chap:DWATcalldatavalueofcallparameter}{attribute}{call data value attribute}
whose value is a DWARF expression. The \DWATcalldatalocationNAME{} attribute
\addtoindexx{call data location attribute}
\DWOPpushobjectaddress{}, it may be left out. The
\DWATcalldatavalueNAME{} attribute describes the value in that location.
The expression should not use registers or memory
-locations that might be clobbered by the call, as it might be evaluated after
-unwinding from the called function back to the caller.
+locations that might be clobbered by the call, as it might be evaluated after
+virtually unwinding from the called function back to the caller.
\needlines{4}
Each call site parameter entry may also have a
\needlines{4}
A label is represented by a debugging information entry with
-\addtoindexx{label entry}
-the tag \DWTAGlabelTARG.
-The entry for a label should be owned by
+\addtoindexx{label entry} the tag \DWTAGlabelTARG.
+The entry for a label is owned by
the debugging information entry representing the scope within
which the name of the label could be legally referenced within
the source program.
The siblings immediately following a try \nolink{block}
entry are its corresponding catch \nolink{block} entries.
-
+\needlines{8}
\section{Declarations with Reduced Scope}
\label{declarationswithreducedscope}
\hypertarget{chap:DWATstartscopeofdeclaration}{}
the value of this attribute is the offset in bytes of the
beginning of the address range for the scope of the entity
from the beginning of the first \addtoindex{range list} entry
-for the containing scope that is not a base selection entry,
-a default selection entry or an end-of-list entry.
+for the containing scope that is not a base
+address entry, a default location
+entry or an end-of-list entry.
\end{enumerate}
\needlines{4}
\item Otherwise, the set of addresses for the scope of the
-entity is specified using a value of class \CLASSrangelistptr{}.
+entity is specified using a value of class \CLASSrnglistsptr{}.
This value indicates the beginning of a \addtoindex{range list}
(see Section \refersec{chap:noncontiguousaddressranges}).
\end{enumerate}
language that allows executable code in a
\nolink{block} before a variable declaration, or where one declaration
containing initialization code may change the scope of a
-subsequent declaration. Consider the following example \addtoindex{C} code:}
+subsequent declaration.}
-\vspace{3mm}
-\begin{lstlisting}
+\needlines{4}
+\textit{Consider the following example \addtoindex{C} code:}
+\par % Needed to end paragraph before listing so that it gets a line number
+\begin{nlnlisting}
float x = 99.99;
int myfunc()
{
float x = 88.99;
return 0;
}
-\end{lstlisting}
+\end{nlnlisting}
\textit{\addtoindex{C} scoping rules require that the value of the
variable \texttt{x} assigned to the variable \texttt{f} in the
DWARF Git Projects / dwarf-doc.git / blobdiff