0x00
\end{alltt}
-Running an MD5 hash over this byte stream, and taking the
+Running an \addtoindex{MD5 hash} over this byte stream, and taking the
low\dash order 64 bits, yields the final signature:
0xd28081e8 dcf5070a.
0x00
\end{alltt}
-Running an MD5 hash over this byte stream, and taking the
+Running an \addtoindex{MD5 hash} over this byte stream, and taking the
low-order 64 bits, yields the final signature: 0xd6d160f5
5589f6e9.
The debugging information entry for a program variable,
formal parameter or constant may have the following attributes:
\begin{enumerate}[1.]
-\item A \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, whose value is a null-terminated
+\item A \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+\addtoindexx{name attribute}
+whose value is a null-terminated
string, containing the data object name as it appears in the
source program. If a variable entry describes
an
tag \livetarg{chap:DWTAGcommonblock}{DW\-\_TAG\-\_common\-\_block}.
The
common \nolink{block}
-entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute whose value
+entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\addtoindexx{name attribute}
+whose value
is a null-terminated string containing the
\livetargi{chap:commonblockreferenceattribute}{common}{common block reference attribute} \nolink{block}
name as it appears in the source program. It may also have a
A namelist is represented by a debugging information entry
with the
tag \livetarg{chap:DWTAGnamelist}{DW\-\_TAG\-\_namelist}.
+\addtoindexx{namelist entry}
If the namelist itself has a
-name, the namelist entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, whose
+name, the namelist entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+\addtoindexx{name attribute}
+whose
value is a null-terminated string containing the namelist’s
name as it appears in the source program.
by a debugging information entry with the tag
\livetarg{chap:DWTAGnamelistitem}{DW\-\_TAG\-\_namelist\-\_item}.
Each such entry is a child of the
-namelist entry, and all of the namelist item entries for a
+namelist entry, and all of the
+namelist item entries for a
+\addtoindexx{namelist item entry}
given namelist are ordered as were the list of names they
correspond to in the source program.
-Each namelist item entry contains a \livelink{chap:DWATnamelistitem}{DW\-\_AT\-\_namelist\-\_item}
-attribute whose value is a reference to the debugging
+Each namelist item entry contains a
+\livelink{chap:DWATnamelistitem}{DW\-\_AT\-\_namelist\-\_item} attribute
+\addtoindexx{namelist item attribute}
+whose
+\addtoindexx{namelist item entry}
+value is a reference to the debugging
information entry representing the declaration of the item
whose name appears in the namelist.
\end{itemize}
-In no case does an attribute use one of the classes \livelink{chap:lineptr}{lineptr},
+In no case does an attribute use
+\addtoindexx{rangelistptr class}
+one
+\addtoindexx{loclistptr class}
+of
+\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
\addtoindex{.debug\_info} or \addtoindex{.debug\_str} section.
\livelink{chap:DWMACINFOvendorext}{DW\-\_MACINFO\-\_vendor\-\_ext} entry.
The macinfo type is encoded as a single byte.
-The encodings are given in
+The encodings
+\addtoindexx{macinfo types!encoding}
+are given in
Table \refersec{tab:macinfotypeencodings}.
it is used by a DWARF consumer to resolve type references to
the type definitions that are contained in type units.
-The type signature for a type T0 is formed from the MD5
-hash of a flattened description of the type. The flattened
+The type signature for a type T0 is formed from the
+\addtoindex{MD5 hash}
+of a flattened description of the type. The flattened
description of the type is a byte sequence derived from the
DWARF encoding of the type as follows:
the type’s context as follows: For each surrounding type
or namespace, beginning with the outermost such construct,
append the letter 'C', the DWARF tag of the construct, and
-the name (taken from the \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute) of the type
+the name (taken from
+\addtoindexx{name attribute}
+the \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute) of the type
+\addtoindexx{name attribute}
or namespace (including its trailing null byte).
\item Append to S the letter 'D', followed by the DWARF tag of
\item \livelink{chap:DWATvtableelemlocation}{DW\-\_AT\-\_vtable\-\_elem\-\_location}
\end{itemize}
-Note that except for the initial \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+Note that except for the initial
+\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+\addtoindexx{name attribute}
attributes are appended in order according to the alphabetical
spelling of their identifier.
\item Visit each child C of the debugging information
entry as follows: If C is a nested type entry or a member
-function entry, and has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, append to
+function entry, and has
+a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, append to
+\addtoindexx{name attribute}
S the letter 'S', the tag of C, and its name; otherwise,
process C recursively by performing Steps 3 through 7,
appending the result to S. Following the last child (or if
expression when possible.)
Once the string S has been formed from the DWARF encoding,
-an MD5 hash is computed for the string and the lower 64 bits
+an \addtoindex{MD5 hash} is computed for the string and the lower 64 bits
are taken as the type signature.
\textit{The string S is intended to be a flattened representation of
\livelink{chap:DWATdeclcolumn}{DW\-\_AT\-\_decl\-\_column} attributes are not included because they
may vary from one source file to the next, and would prevent
two otherwise identical type declarations from producing the
+\addtoindexx{MD5 hash}
same hash.}
\end{itemize}
The C++ example in
Figure \refersec{fig:namespaceexamplesourcefragment}
-is used to illustrate the representation of namespaces.
+is used
+\addtoindexx{namespace (C++)!example}
+to illustrate the representation of namespaces.
\begin{figure}[here]
\begin{lstlisting}
\livetarg{chap:DWATuseUTF8}{DW\-\_AT\-\_use\-\_UTF8}
&\livelinki{chap:DWATuseUTF8compilationunitusesutf8strings}{Compilation unit uses UTF-8 strings}{compilation unit uses UTF-8 strings} \\
\livetarg{chap:DWATvariableparameter}{DW\-\_AT\-\_variable\-\_parameter}
-&\livelink{chap:DWATvariableparameternonconstantparameterflag}{Non-constant parameter flag}{non-constant parameter flag} \\
+&\livelinki{chap:DWATvariableparameternonconstantparameterflag}{Non-constant parameter flag}{non-constant parameter flag} \\
\livetarg{chap:DWATvirtuality}{DW\-\_AT\-\_virtuality}
&\livelinki{chap:DWATvirtualityvirtualityindication}{Virtuality indication}{virtuality indication} \\
&\livelinki{chap:DWATvirtualityvirtualityofbaseclass}{Virtuality of base class} {virtuality of base class} \\
A
\addtoindexx{location description!memory}
-memory location description consists of a non\dash empty DWARF
+memory location description
+\addtoindexx{memory location description}
+consists of a non\dash empty DWARF
expression (see
Section \refersec{chap:dwarfexpressions}
), whose value is the address of
\section{Visibility of Declarations}
\label{chap:visibilityofdeclarations}
-\textit{Several languages (such as Modula-2)
+\textit{Several languages (such as \addtoindex{Modula-2})
have the concept of the visibility of a declaration. The
visibility specifies which declarations are to be
visible outside of the entity in which they are
\hypertarget{chap:DWATnamenameofdeclaration}
debugging information entry
\addtoindexx{identifier names}
-representing a program entity
+representing
+\addtoindexx{names!identifier}
+a program entity
that has been given a name may have a
\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
-whose value is a string representing the name as it appears in
+whose
+\addtoindexx{name attribute}
+value is a 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
\textit{Because the names of program objects described by DWARF are the
names as they appear in the source program, implementations
of language translators that use some form of mangled name
+\addtoindex{mangled names}
(as do many implementations of C++) should use the unmangled
-form of the name in the DWARF \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+form of the name in the
+DWARF \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+\addtoindexx{name attribute}
including the keyword operator (in names such as “operator
+”), if present. See also
Section \refersec{chap:linkagenames} regarding the use
-of \livelink{chap:DWATlinkagename}{DW\-\_AT\-\_linkage\-\_name} for mangled names. Sequences of
+of \livelink{chap:DWATlinkagename}{DW\-\_AT\-\_linkage\-\_name} for
+\addtoindex{mangled names}
+mangled names.
+Sequences of
multiple whitespace characters may be compressed.}
\section{Data Locations and DWARF Procedures}
\subsection{Non\dash Contiguous Address Ranges}
\label{chap:noncontiguousaddressranges}
When the set of addresses of a debugging information entry
+\addtoindexx{non-contiguous address ranges}
cannot be described as a single contiguous range, the entry has
a \livelink{chap:DWATranges}{DW\-\_AT\-\_ranges} attribute
\addtoindexx{ranges attribute}
Generally, any debugging information
entry that
\hypertarget{chap:DWATdescriptionartificialnameordescription}
-has, or may have, a
+has, or may have,
+\addtoindexx{name attribute}
+a
\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, may
also have
\addtoindexx{description attribute}
make use of implementation defined names within
object files that are different from the identifier names
(see Section \refersec{chap:identifiernames}) of entities as they appear in the
-source. Such names, sometimes known as mangled names,
+source. Such names, sometimes known
+\addtoindex{names!mangled}
+as
+\addtoindexx{mangled names}
+mangled names,
are used in various ways, such as: to encode additional
information about an entity, to distinguish multiple entities
that have the same name, and so on. When an entity has an
section.
\textit{Some computer architectures employ more than one instruction
-set (for example, the ARM and MIPS architectures support
+set (for example, the ARM
\addtoindexx{ARM instruction set architecture}
+and
+MIPS architectures support
+\addtoindexx{MIPS instruction set architecture}
a 32\dash bit as well as a 16\dash bit instruction set). Because the
instruction set is a function of the program counter, it is
convenient to encode the applicable instruction set in the
version number.
\item header\_length \\
-The number of bytes following the header\_length field to the
+The number of bytes following the \addtoindex{header\_length} field to the
beginning of the first byte of the line number program itself.
In the 32\dash bit DWARF format, this is a 4\dash byte unsigned
length; in the 64\dash bit DWARF format, this field is an
(see Section \refersec{datarep:32bitand64bitdwarfformats}).
\item minimum\_instruction\_length (ubyte) \\
+\addtoindexx{minimum\_instruction\_length}
The size in bytes of the smallest target machine
instruction. Line number program opcodes that alter
the address and op\_index registers use this and
+\addtoindexx{maximum\_operations\_per\_instruction}
maximum\-\_operations\-\_per\-\_instruction in their calculations.
\item maximum\_operations\_per\_instruction (ubyte) \\
-The maximum number of individual operations that may be
+The
+\addtoindexx{maximum\_operations\_per\_instruction}
+maximum number of individual operations that may be
encoded in an instruction. Line number program opcodes
-that alter the address and op\_index registers use this and
-minimum\_instruction\_length in their calculations. For non-VLIW
+that alter the address and
+\addtoindex{op\_index} registers use this and
+\addtoindex{minimum\_instruction\_length}
+in their calculations.
+For non-VLIW
architectures, this field is 1, the op\_index register is always
0, and the operation pointer is simply the address register.
If the resulting opcode is greater than 255, a standard opcode
must be used instead.
-When maximum\_operations\_per\_instruction is 1, the operation
+When \addtoindex{maximum\_operations\_per\_instruction} is 1, the operation
advance is simply the address increment divided by the
-minimum\_instruction\_length.
+\addtoindex{minimum\_instruction\_length}.
To decode a special opcode, subtract the opcode\_base from
the opcode itself to give the \textit{adjusted opcode}.
address +
-minimum\_instruction\_length *
-((op\_index + operation advance) /
-maximum\_operations\_per\_instruction)
+\addtoindex{minimum\_instruction\_length} *
+((\addtoindex{op\_index} + operation advance) /
+\addtoindex{maximum\_operations\_per\_instruction})
\end{myindentpara}
new op\_index =
\begin{myindentpara}{1cm}
-(op\_index + operation advance) \% maximum\_operations\_per\_instruction
+(op\_index + operation advance) \% \addtoindex{maximum\_operations\_per\_instruction}
\end{myindentpara}
\end{myindentpara}
-\textit{When the maximum\_operations\_per\_instruction field is 1,
+\textit{When the \addtoindex{maximum\_operations\_per\_instruction} field is 1,
op\_index is always 0 and these calculations simplify to those
given for addresses in
\addtoindex{DWARF Version 3}.}
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 minimum\_instruction\_length field of the header.
+operand by the \addtoindex{minimum\_instruction\_length} field of the header.
\textit{Existing assemblers cannot emit \livelink{chap:DWLNSadvancepc}{DW\-\_LNS\-\_advance\-\_pc} or special
opcodes because they cannot encode LEB128 numbers or judge when
\textit{Some languages, such as
\addtoindex{C} and
addtoindex{C++}, provide a way to replace
+\addtoindex{macro information}
text in the source program with macros defined either in the
source file itself, or in another file included by the source
file. Because these macros are not themselves defined in the
\subsection{Macinfo Types}
\label{chap:macinfotypes}
-The valid macinfo types are as follows:
+The valid \addtoindex{macinfo types} are as follows:
\begin{tabular}{ll}
\livelink{chap:DWMACINFOdefine}{DW\-\_MACINFO\-\_define}
In the case of a \livelink{chap:DWMACINFOdefine}{DW\-\_MACINFO\-\_define} entry, the value of this
string will be the name of the macro symbol that was defined
-at the indicated source line, followed immediately by the macro
-formal parameter list including the surrounding parentheses (in
+at the indicated source line, followed immediately by the
+\addtoindex{macro formal parameter list}
+including the surrounding parentheses (in
the case of a function-like macro) followed by the definition
string for the macro. If there is no formal parameter list,
then the name of the defined macro is followed directly by
\subsection[Normal and Partial CU Entries]{Normal and Partial Compilation Unit Entries}
\label{chap:normalandpartialcompilationunitentries}
-A normal compilation unit is represented by a debugging
-information entry with the
+A \addtoindex{normal compilation unit} is represented by a
+debugging information entry with the
tag \livetarg{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}. A partial
compilation unit is represented by a debugging information
entry with the
\refersec{chap:locationlists}) and range lists
(see Section \refersec{chap:noncontiguousaddressranges}).
-\item A \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute whose value is a null\dash terminated
+\item A \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\addtoindexx{name attribute}
+whose value is a null\dash terminated
string
\hypertarget{chap:DWATnamepathnameofcompilationsource}
containing the full or relative path name of the primary
\label{fig:languagenames}
\begin{tabular}{ll}
Language name & Meaning\\ \hline
-\livetarg{chap:DWLANGAda83}{DW\-\_LANG\-\_Ada83} \dag&ISO Ada:1983 \addtoindexx{Ada} \\
+\livetarg{chap:DWLANGAda83}{DW\-\_LANG\-\_Ada83} \dag&ISO \addtoindex{Ada}:1983 \addtoindexx{Ada} \\
\livetarg{chap:DWLANGAda95}{DW\-\_LANG\-\_Ada95} \dag&ISO Ada:1995 \addtoindexx{Ada} \\
\livetarg{chap:DWLANGC}{DW\-\_LANG\-\_C}&Non-standardized C, such as K\&R \\
\livetarg{chap:DWLANGC89}{DW\-\_LANG\-\_C89}&ISO C:1989 \\
-\livetarg{chap:DWLANGC99}{DW\-\_LANG\-\_C99} & ISO C:1999 \\
-\livetarg{chap:DWLANGCplusplus}{DW\-\_LANG\-\_C\-\_plus\-\_plus}&ISO C++:1998 \\
-\livetarg{chap:DWLANGCobol74}{DW\-\_LANG\-\_Cobol74}& ISO Cobol:1974 \\
-\livetarg{chap:DWLANGCobol85}{DW\-\_LANG\-\_Cobol85} & ISO Cobol:1985 \\
-\livetarg{chap:DWLANGD}{DW\-\_LANG\-\_D} \dag & D \\
-\livetarg{chap:DWLANGFortran77}{DW\-\_LANG\-\_Fortran77} &ISO FORTRAN 77\\
-\livetarg{chap:DWLANGFortran90}{DW\-\_LANG\-\_Fortran90} & ISO Fortran 90\\
-\livetarg{chap:DWLANGFortran95}{DW\-\_LANG\-\_Fortran95} & ISO Fortran 95\\
-\livetarg{chap:DWLANGJava}{DW\-\_LANG\-\_Java} & Java\\
-\livetarg{chap:DWLANGModula2}{DW\-\_LANG\-\_Modula2} & ISO Modula\dash 2:1996\\
-\livetarg{chap:DWLANGObjC}{DW\-\_LANG\-\_ObjC} & Objective C\\
-\livetarg{chap:DWLANGObjCplusplus}{DW\-\_LANG\-\_ObjC\-\_plus\-\_plus} & Objective C++\\
-\livetarg{chap:DWLANGPascal83}{DW\-\_LANG\-\_Pascal83} & ISO Pascal:1983\\
-\livetarg{chap:DWLANGPLI}{DW\-\_LANG\-\_PLI} \dag & ANSI PL/I:1976\\
-\livetarg{chap:DWLANGPython}{DW\-\_LANG\-\_Python} \dag & Python\\
-\livetarg{chap:DWLANGUPC}{DW\-\_LANG\-\_UPC} &Unified Parallel C\\ \hline
+\livetarg{chap:DWLANGC99}{DW\-\_LANG\-\_C99} & ISO \addtoindex{C}:1999 \\
+\livetarg{chap:DWLANGCplusplus}{DW\-\_LANG\-\_C\-\_plus\-\_plus}&ISO \addtoindex{C++}:1998 \\
+\livetarg{chap:DWLANGCobol74}{DW\-\_LANG\-\_Cobol74}& ISO \addtoindex{Cobol}:1974 \\
+\livetarg{chap:DWLANGCobol85}{DW\-\_LANG\-\_Cobol85} & ISO \addtoindex{Cobol}:1985 \\
+\livetarg{chap:DWLANGD}{DW\-\_LANG\-\_D} \dag & D \addtoindexx{D language} \\
+\livetarg{chap:DWLANGFortran77}{DW\-\_LANG\-\_Fortran77} &ISO \addtoindex{FORTRAN} 77\\
+\livetarg{chap:DWLANGFortran90}{DW\-\_LANG\-\_Fortran90} & ISO \addtoindex{Fortran 90}\\
+\livetarg{chap:DWLANGFortran95}{DW\-\_LANG\-\_Fortran95} & ISO \addtoindex{Fortran 95}\\
+\livetarg{chap:DWLANGJava}{DW\-\_LANG\-\_Java} & \addtoindex{Java}\\
+\livetarg{chap:DWLANGModula2}{DW\-\_LANG\-\_Modula2} & ISO Modula\dash 2:1996 \addtoindexx{Modula-2}\\
+\livetarg{chap:DWLANGObjC}{DW\-\_LANG\-\_ObjC} & \addtoindex{Objective C}\\
+\livetarg{chap:DWLANGObjCplusplus}{DW\-\_LANG\-\_ObjC\-\_plus\-\_plus} & \addtoindex{Objective C++}\\
+\livetarg{chap:DWLANGPascal83}{DW\-\_LANG\-\_Pascal83} & ISO \addtoindex{Pascal}:1983\\
+\livetarg{chap:DWLANGPLI}{DW\-\_LANG\-\_PLI} \dag & ANSI \addtoindex{PL/I}:1976\\
+\livetarg{chap:DWLANGPython}{DW\-\_LANG\-\_Python} \dag & \addtoindex{Python}\\
+\livetarg{chap:DWLANGUPC}{DW\-\_LANG\-\_UPC} &\addtoindex{Unified Parallel C}\\ \hline
\dag \ \ Support for these languages is limited.& \\
\end{tabular}
\end{figure}
information for this compilation unit
(see Section \refersec{chap:linenumberinformation}).
-\item A \livelink{chap:DWATmacroinfo}{DW\-\_AT\-\_macro\-\_info} attribute whose value is a section
+\item A \livelink{chap:DWATmacroinfo}{DW\-\_AT\-\_macro\-\_info} attribute
+\addtoindex{macro information attribute}
+whose value is a section
\hypertarget{chap:DWATmacroinfomacroinformation}
offset to the macro information for this compilation unit.
This information is placed in a separate object file section
\livetarg{chap:DWIDcasesensitive}{DW\-\_ID\-\_case\-\_sensitive} is the default for all compilation units
that do not have this attribute. It indicates that names given
-as the values of \livelink{chap:DWATname}{DW\-\_AT\-\_name} attributes in debugging information
+as the values of \livelink{chap:DWATname}{DW\-\_AT\-\_name} attributes
+\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
to the case of identifier names when doing identifier lookups.
\item A \livelink{chap:DWATmainsubprogram}{DW\-\_AT\-\_main\-\_subprogram} attribute, which is a \livelink{chap:flag}{flag}
+\addtoindexx{main subprogram attribute}
whose presence indicates
\hypertarget{chap:DWATmainsubprogramunitcontainingmainorstartingsubprogram}
that the compilation unit contains a
\label{chap:moduleentries}
\textit{Several languages have the concept of a ``module.''
\addtoindexx{Modula-2}
-A Modula\dash 2 definition module may be represented by a module
+A Modula\dash 2 definition module
+\addtoindexx{Modula-2!definition module}
+may be represented by a module
entry containing a
\addtoindex{declaration attribute}
(\livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration}). A
debugging information entries describing program entities
whose declaration scopes end at the end of the module itself.
-If the module has a name, the module entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name}
-attribute whose value is a null\dash terminated string containing
+If the module has a name, the module entry has a
+\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\addtoindexx{name attribute}
+whose value is a null\dash terminated string containing
the module name as it appears in the source program.
-The module entry may have either a \livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc} and
+The \addtoindex{module entry} may have either a
+\livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc} and
\livelink{chap:DWAThighpc}{DW\-\_AT\-\_high\-\_pc}
pair
\addtoindexx{high PC attribute}
\subsection{Namespace Entries}
\label{chap:namespaceentries}
\textit{\addtoindex{C++} has the notion of a namespace, which provides a way to
+\addtoindexx{namespace (C++)}
implement name hiding, so that names of unrelated things
do not accidentally clash in the
\addtoindex{global namespace} when an
information in a previous extension entry of the namespace
nor need it duplicate information in the original namespace
entry. (Thus, for a namespace with a name,
-a \livelink{chap:DWATname}{DW\-\_AT\-\_name}
-attribute need only be attached directly to the original
+a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\addtoindexx{name attribute}
+need only be attached directly to the original
\livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace} entry.)
-Namespace and namespace extension entries may own other
+Namespace and namespace extension entries may own
+\addtoindexx{namespace extension entry}
+other
+\addtoindexx{namespace declaration entry}
debugging information entries describing program entities
whose declarations occur in the namespace.
\textit{The \addtoindex{C++} \addtoindex{global namespace}
(the
\addtoindexx{global namespace|see{namespace (C++), global}}
-namespace referred to by
+namespace
+\addtoindexx{namespace (C++)!global}
+referred to by
``::f'', for example) is not explicitly represented in
DWARF with a namespace entry (thus mirroring the situation
in \addtoindex{C++} source).
\textit{The \addtoindex{C++}
compilation unit specific ``unnamed namespace'' may
+\addtoindexx{namespace (C++)!unnamed}
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).
final namespace declaration of a compilation unit; this is a
quality\dash of\dash implementation issue and no specific requirements
are given here. If only the final namespace is represented,
+\addtoindexx{namespace (C++)!using declaration}
it is impossible for a debugger to interpret using declaration
references in exactly the manner defined by the
\addtoindex{C++} language.
size of the debug information and significant duplication of
information across compilation units.
The \addtoindex{C++} namespace std,
-for example, is large and will probably be referenced in
+for example,
+\addtoindexx{namespace (C++)!std}
+is large and will probably be referenced in
every \addtoindex{C++} compilation unit.
}
An imported declaration may also have a
\livelink{chap:DWATname}{DW\-\_AT\-\_name}
attribute
+\addtoindexx{name attribute}
whose value is a null\dash terminated string containing the
name, as it appears in the source program, by which the
imported entity is to be known in the context of the imported
\textit{A \addtoindex{C++} namespace alias may be represented by an imported
\hypertarget{chap:DWATimportnamespacealias}
-declaration entry with a name attribute whose value is
+declaration entry
+\addtoindexx{namespace (C++)!alias}
+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
\textit{A \addtoindex{C++} using declaration may be represented by one or more
\hypertarget{chap:DWATimportnamespaceusingdeclaration}
-imported declaration entries. When the using declaration
+imported
+\addtoindexx{namespace (C++)!using declaration}
+declaration entries. When the using declaration
refers to an overloaded function, there is one imported
declaration entry corresponding to each overloading. Each
imported declaration entry has no name attribute but it does
module entry by the same name as it is declared in the module.
\textit{A \addtoindex{C++} using directive
-may be represented by an imported module
+may be represented by an
+\addtoindexx{namespace (C++)!using directive}
+imported module
\hypertarget{chap:DWATimportnamespaceusingdirective}
entry, with an import attribute referring to the namespace
entry of the appropriate extension of the namespace (which
A
\hypertarget{chap:DWATmainsubprogrammainorstartingsubprogram}
-subroutine entry may contain a \livelink{chap:DWATmainsubprogram}{DW\-\_AT\-\_main\-\_subprogram}
-attribute which is
+subroutine entry
+may contain a
+\livelink{chap:DWATmainsubprogram}{DW\-\_AT\-\_main\-\_subprogram}
+attribute
+\addtoindexx{main subprogram attribute}
+which is
a \livelink{chap:flag}{flag} whose presence indicates that the
subroutine has been identified as the starting function of
the program. If more than one subprogram contains this
entry with the
tag \livetarg{chap:DWTAGtemplatetypeparameter}{DW\-\_TAG\-\_template\-\_type\-\_parameter}.
Each
-such entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, whose value is a
+such entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+\addtoindexx{name attribute}
+whose value is a
null\dash terminated string containing the name of the formal
type parameter as it appears in the source program. The
\addtoindexx{formal type parameter|see{template type parameter entry}}
\addtoindexx{abstract instance!tree}
an ``abstract instance tree.'' However, in the case where
an abstract instance tree is nested within another abstract
-instance tree, the entries in the nested abstract instance
+instance tree, the entries in the
+\addtoindex{nested abstract instance}
tree are not considered to be entries in the outer abstract
instance tree.
itself, is known as a ``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 nested concrete instance tree are not considered to
+in the \addtoindex{nested concrete inline instance} tree
+are not considered to
be entries in the outer concrete instance tree.
\textit{Concrete inlined instance trees are defined so that no entry
\item Entries in the concrete instance tree which are associated
with entries in the abstract instance tree such that neither
-has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, and neither is referenced by
+has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+\addtoindexx{name attribute}
+and neither is referenced by
any other debugging information entry, may be omitted. This
may happen for debugging information entries in the abstract
instance trees that became unnecessary in the concrete instance
the relocated address of the target subprogram.
\item If the value is of class string, then the value is the
-(possibly mangled) name of the target subprogram.
+(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
indicates that the containing subroutine is a trampoline but
program, then the corresponding
lexical \livelink{chap:lexicalblockentry}{block} entry has a
\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute whose
+\addtoindexx{name attribute}
value is a null\dash terminated string
containing the name of the lexical \livelink{chap:lexicalblock}{block}
as it appears in
The label entry has a \livelink{chap:DWATlowpc}{DW\-\_AT\-\_low\-\_pc} attribute whose value
is the relocated address of the first machine instruction
generated for the statement identified by the label in
-the source program. The label entry also has a \livelink{chap:DWATname}{DW\-\_AT\-\_name}
-attribute whose value is a null-terminated string containing
+the source program. The label entry also has a
+\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\addtoindexx{name attribute}
+whose value is a null-terminated string containing
the name of the label as it appears in the source program.
\livetarg{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}.
A \addtoindex{base type entry}
-has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute whose value is
+has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+whose
+\addtoindexx{name attribute}
+value is
a null\dash terminated string containing the name of the base type
as recognized by the programming language of the compilation
unit containing the base type entry.
the tag \livetarg{chap:DWTAGunspecifiedtype}{DW\-\_TAG\-\_unspecified\-\_type}.
If a name has been given
to the type, then the corresponding unspecified type entry
-has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute whose value is
+has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\addtoindexx{name attribute}
+whose value is
a null\dash terminated
string containing the name as it appears in the source program.
If a name has been given to the modified type in the source
program, then the corresponding modified type entry has
-a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute whose value is a null-terminated
+a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\addtoindexx{name attribute}
+whose value is a null\dash terminated
string containing the modified type name as it appears in
the source program.
A named type that is defined in terms of another type
definition is represented by a debugging information entry with
the tag \livetarg{chap:DWTAGtypedef}{DW\-\_TAG\-\_typedef}.
-The typedef entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name}
-attribute whose value is a null-terminated string containing
+The typedef entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\addtoindexx{name attribute}
+whose value is a null\dash terminated string containing
the name of the typedef as it appears in the source program.
The typedef entry may also contain a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute whose
given to
\addtoindexx{array!declaration of type}
the array type in the source program, then the corresponding
-array type entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute whose value is a
-null-terminated string containing the array type name as it
+array type entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\addtoindexx{name attribute}
+whose value is a
+null\dash terminated string containing the array type name as it
appears in the source program.
The
respectively. If a name has been given to the structure,
union, or class in the source program, then the corresponding
structure type, union type, or class type entry has a
-\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute whose value is a null\dash terminated string
+\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\addtoindexx{name attribute}
+whose value is a null\dash terminated string
containing the type name as it appears in the source program.
The members of a structure, union, or class are represented
entries with the
tag \livetarg{chap:DWTAGinterfacetype}{DW\-\_TAG\-\_interface\-\_type}.
-An interface type entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, whose
-value is a null-terminated string containing the type name
+An interface type entry has
+a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+\addtoindexx{name attribute}
+whose
+value is a null\dash terminated string containing the type name
as it appears in the source program.
The members of an interface are represented by debugging
Each
such entry is a child of the class or structure type entry.
-An access declaration entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, whose
-value is a null-terminated string representing the name used
+An access declaration entry has
+a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+\addtoindexx{name attribute}
+whose
+value is a null\dash terminated string representing the name used
in the declaration in the source program, including any class
or structure qualifiers.
A data member (as opposed to a member function) is
represented by a debugging information entry with the
tag \livetarg{chap:DWTAGmember}{DW\-\_TAG\-\_member}.
-The member entry for a named member has
-a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute whose value is a null-terminated
+The
+\addtoindexx{member entry (data)}
+member entry for a named member has
+a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\addtoindexx{name attribute}
+whose value is a null\dash terminated
string containing the member name as it appears in the source
program. If the member entry describes an
\addtoindex{anonymous union},
the
name attribute is omitted or consists of a single zero byte.
-The data member entry has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute to denote
+The data member entry has a
+\livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute to denote
+\addtoindexx{member entry (data)}
the type of that member.
A data member entry may
A data member
\hypertarget{chap:DWATmutablemutablepropertyofmemberdata}
-entry may have a \livelink{chap:DWATmutable}{DW\-\_AT\-\_mutable} attribute,
+entry
+\addtoindexx{member entry (data)}
+may
+\addtoindexx{mutable attribute}
+have a \livelink{chap:DWATmutable}{DW\-\_AT\-\_mutable} attribute,
which is a \livelink{chap:flag}{flag}.
This attribute indicates whether the data
member was declared with the mutable storage class specifier.
conventions that are appropriate to the current language on
the target system.
-The member entry corresponding to a data member that is
+The member entry
+\addtoindexx{member entry (data)}
+corresponding to a data member that is
\hypertarget{chap:DWATdatabitoffsetdatamemberbitlocation}
defined
\hypertarget{chap:DWATdatamemberlocationdatamemberlocation}
\subsection{Member Function Entries}
\label{chap:memberfunctionentries}
-A member function is represented by a debugging information
-entry with the tag \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}.
+A member function is represented by a
+\addtoindexx{member function entry}
+debugging information entry with the
+tag \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}.
The member function entry
may contain the same attributes and follows the same rules
as non\dash member global subroutine entries
template definition is represented by a debugging information
entry with the tag
\livelink{chap:DWTAGtemplatetypeparameter}{DW\-\_TAG\-\_template\-\_type\-\_parameter}. Each
-such entry may have a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, whose value is
+such entry may have a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+\addtoindexx{name attribute}
+whose value is
a null\dash terminated string containing the name of the formal
type parameter as it appears in the source program. The
template type parameter entry also has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute
entry with the
tag \livetarg{chap:DWTAGtemplatevalueparameter}{DW\-\_TAG\-\_template\-\_value\-\_parameter}.
Each
-such entry may have a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, whose value is
+such entry may have a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+\addtoindexx{name attribute}
+whose value is
a null\dash terminated string containing the name of the formal
value parameter as it appears in the source program.
The
\addtoindexx{discriminant (entry)}
separate debugging information entry which
is a child of the variant part entry. This entry has the form
-of a structure data member entry. The variant part entry will
+of a
+\addtoindexx{member entry (data)!as discriminant}
+structure data member entry. The variant part entry will
\addtoindexx{discriminant attribute}
have a
\livelink{chap:DWATdiscr}{DW\-\_AT\-\_discr} attribute
logical condition that tests whether a given data item’s
value matches one of a set of constant values. If a name
has been given to the condition, the condition entry has a
-\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute whose value is a null\dash terminated string
+\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\addtoindexx{name attribute}
+whose value is a null\dash terminated string
giving the condition name as it appears in the source program.
The condition entry's parent entry describes the conditional
If a name has been given to the enumeration type in the source
program, then the corresponding enumeration type entry has
-a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute whose value is a null\dash terminated
+a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\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
Each \addtoindex{enumerator entry} has a
\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, whose
+\addtoindexx{name attribute}
value is a null\dash terminated string containing the name of the
\hypertarget{chap:DWATconstvalueenumerationliteralvalue}
enumeration literal as it appears in the source program.
tag \livetarg{chap:DWTAGsubroutinetype}{DW\-\_TAG\-\_subroutine\-\_type}.
If a name has
been given to the subroutine type in the source program,
-then the corresponding subroutine type entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name}
-attribute whose value is a null\dash terminated string containing
+then the corresponding subroutine type entry has
+a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\addtoindexx{name attribute}
+whose value is a null\dash terminated string containing
the subroutine type name as it appears in the source program.
If the subroutine type describes a function that returns
with the tag \livetarg{chap:DWTAGstringtype}{DW\-\_TAG\-\_string\-\_type}.
If a name has been given to
the string type in the source program, then the corresponding
-string type entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute whose value is
+string type entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\addtoindexx{name attribute}
+whose value is
a null\dash terminated string containing the string type name as
it appears in the source program.
A set is represented by a debugging information entry with
the tag \livetarg{chap:DWTAGsettype}{DW\-\_TAG\-\_set\-\_type}.
If a name has been given to the
-set type, then the set type entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+set type, then the set type entry has
+a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\addtoindexx{name attribute}
whose value is a null\dash terminated string containing the
set type name as it appears in the source program.
tag \livetarg{chap:DWTAGsubrangetype}{DW\-\_TAG\-\_subrange\-\_type}.
If a name has been
given to the subrange type, then the subrange type entry
-has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute whose value is a null\dash terminated
+has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\addtoindexx{name attribute}
+whose value is a null\dash terminated
string containing the subrange type name as it appears in
the source program.
The default lower bound is 1 for
\addtoindex{Ada}, \addtoindex{COBOL},
\addtoindex{Fortran},
-\addtoindex{Modula}\dash 2,
+\addtoindex{Modula-2},
\addtoindex{Pascal} and
\addtoindex{PL/I}.
the tag \livetarg{chap:DWTAGptrtomembertype}{DW\-\_TAG\-\_ptr\-\_to\-\_member\-\_type}.
If the pointer to member type has a name, the pointer to
-member entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, whose value is a
+member entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+\addtoindexx{name attribute}
+whose value is a
null\dash terminated string containing the type name as it appears
in the source program.
the
\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, whose value
+the file type entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+\addtoindexx{name attribute}
+whose value
is a null\dash terminated string containing the type name as it
appears in the source program.
by a debugging information entry with the tag
\livetarg{chap:DWTAGtemplatealias}{DW\-\_TAG\-\_template\-\_alias}.
The template alias entry has a
-\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute whose value is a null\dash terminated string
+\livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
+\addtoindexx{name attribute}
+whose value is a null\dash terminated string
containing the name of the template alias as it appears in
the source program. The template alias entry also contains a
\livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute whose value is a reference to the type
by a debugging information entry with the tag
\livelink{chap:DWTAGtemplatetypeparameter}{DW\-\_TAG\-\_template\-\_type\-\_parameter}.
Each such entry may have
-a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, whose value is a null\dash terminated
+a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+\addtoindexx{name attribute}
+whose value is a null\dash terminated
string containing the name of the formal type parameter as it
appears in the source program. The template type parameter
entry also has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute describing the actual
represented by a debugging information entry with the tag
\livelink{chap:DWTAGtemplatevalueparameter}{DW\-\_TAG\-\_template\-\_value\-\_parameter}.
Each such entry may have
-a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute, whose value is a null\dash terminated
+a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute,
+\addtoindexx{name attribute}
+whose value is a null\dash terminated
string containing the name of the formal value parameter
as it appears in the source program. The template value
parameter entry also has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute describing
DWARF Git Projects / dwarf-doc.git / commitdiff