Program variables, formal parameters and constants are
represented by debugging information entries with the tags
-DW\_TAG\_variable, DW\_TAG\_formal\_parameter and DW\_TAG\_constant,
+\livetarg{chap:DWTAGvariable}{DW\_TAG\_variable},
+\livetarg{chap:DWTAGformalparameter}{DW\_TAG\_formal\_parameter} and
+\livetarg{chap:DWTAGconstant}{DW\_TAG\_constant},
respectively.
\textit{The tag DW\_TAG\_constant is used for languages that
\section{Common Block Entries}
\label{chap:commonblockentries}
A Fortran common block may be described by a debugging
-information entry with the tag DW\_TAG\_common\_block. The
+information entry with the
+tag \livetarg{chap:DWTAGcommonblock}{DW\_TAG\_common\_block}.
+The
common block entry has a DW\_AT\_name attribute whose value
is a null-terminated string containing the common block
name as it appears in the source program. It may also have a
as a replacement for the list of names in various contexts.}
A namelist is represented by a debugging information entry
-with the tag DW\_TAG\_namelist. If the namelist itself has a
+with the
+tag \livetarg{chap:DWTAGnamelist}{DW\_TAG\_namelist}.
+If the namelist itself has a
name, the namelist entry has a DW\_AT\_name attribute, whose
value is a null-terminated string containing the namelist’s
name as it appears in the source program.
Each name that is part of the namelist is represented
by a debugging information entry with the tag
-DW\_TAG\_namelist\_item. Each such entry is a child of the
+\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
given namelist are ordered as were the list of names they
correspond to in the source program.
kind of debugging information entry that has a DW\-\_AT\-\_location
attribute. If a suitable entry is not otherwise available,
a DWARF procedure can be represented using a debugging
-information entry with the tag DW\-\_TAG\-\_dwarf\-\_procedure
+information entry with the
+tag \livetarg{chap:DWTAGdwarfprocedure}{DW\-\_TAG\-\_dwarf\-\_procedure}
together with a DW\-\_AT\-\_location attribute.
A DWARF procedure
\label{chap:normalandpartialcompilationunitentries}
A normal compilation unit is represented by a debugging
-information entry with the tag DW\_TAG\_compile\_unit. A partial
+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 tag DW\_TAG\_partial\_unit.
+entry with the
+tag \livetarg{chap:DWTAGpartialunit}{DW\_TAG\_partial\_unit}.
In a simple normal compilation, a single compilation unit with
the tag
\subsection{Imported Unit Entries}
\label{chap:importedunitentries}
The place where a normal or partial unit is imported is
-represented by a debugging information entry with the tag
-DW\_TAG\_imported\_unit. An imported unit entry contains a
+represented by a debugging information entry with the
+tag \livetarg{chap:DWTAGimportedunit}{DW\_TAG\_imported\_unit}.
+An imported unit entry contains a
DW\_AT\_import attribute whose value is a reference to the
normal or partial compilation unit whose declarations logically
belong at the place of the imported unit entry.
information entries in other compilation units and type units.
A type unit is represented by a debugging information entry
-with the tag DW\-\_TAG\-\_type\-\_unit.
+with the tag \livetarg{chap:DWTAGtypeunit}{DW\-\_TAG\-\_type\-\_unit}.
A type unit entry owns debugging
information entries that represent the definition of a single
type, plus additional debugging information entries that may
has no concept of a corresponding module body).}
A module is represented by a debugging information entry
-with the tag DW\_TAG\_module. Module entries may own other
+with the
+tag \livetarg{chap:DWTAGmodule}{DW\_TAG\_module}.
+Module entries may own other
debugging information entries describing program entities
whose declaration scopes end at the end of the module itself.
application is linked together.}
A namespace is represented by a debugging information entry
-with the tag DW\-\_TAG\-\_namespace. A namespace extension is
-represented by a DW\-\_TAG\-\_namespace entry with a DW\-\_AT\-\_extension
+with the
+tag \livetarg{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace}.
+A namespace extension is
+represented by a DW\-\_TAG\-\_namespace entry
+with a DW\-\_AT\-\_extension
attribute referring to the previous extension, or if there
-is no previous extension, to the original DW\-\_TAG\-\_namespace
+is no previous extension, to the original
+DW\-\_TAG\-\_namespace
entry. A namespace extension entry does not need to duplicate
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 DW\_AT\_name
+entry. (Thus, for a namespace with a name,
+a DW\_AT\_name
attribute need only be attached directly to the original
DW\-\_TAG\-\_namespace entry.)
}
An imported declaration is represented by one or
-more debugging information entries with the tag
-DW\_TAG\_imported\_declaration. When an overloaded entity
+more debugging information entries with the
+tag \livetarg{chap:DWTARGimporteddeclaration}{DW\_TAG\_imported\_declaration}.
+When an overloaded entity
is imported, there is one imported declaration entry for
each overloading. Each imported declaration entry has a
DW\_AT\_import attribute, whose value is a reference to the
}
An imported module declaration is represented by a debugging
-information entry with the tag DW\-\_TAG\-\_imported\-\_module. An
+information entry with the
+tag \livetarg{chap:DWTAGimportedmodule}{DW\-\_TAG\-\_imported\-\_module}.
+An
imported module entry contains a DW\-\_AT\-\_import attribute
whose value is a reference to the module or namespace entry
containing the definition and/or declaration entries for
points:
\begin{tabular}{lp{9.0cm}}
-DW\_TAG\_subprogram & A subroutine or function. \\
+\livetarg{chap:DWTAGsubprogram}{DW\_TAG\_subprogram} & A subroutine or function. \\
DW\_TAG\_inlined\_subroutine & A particular inlined
instance of a subroutine or function. \\
-DW\_TAG\_entry\_point & An alternate entry point. \\
+\livetarg{chap:DWTAGentrypoint}{DW\_TAG\_entry\_point} & An alternate entry point. \\
\end{tabular}
\subsection{General Subroutine and Entry Point Information}
The unspecified parameters of a variable parameter list are
represented by a debugging information entry with the tag
-DW\_TAG\_unspecified\_parameters.
+\livetarg{chap:DWTAGunspecifiedparameters}{DW\_TAG\_unspecified\_parameters}.
The entry for a subroutine that includes a Fortran common block
-has a child entry with the tag
-DW\-\_TAG\-\_common\-\_inclusion. The
+has a child entry with the
+tag \livetarg{chap:DWTAGcommoninclusion}{DW\-\_TAG\-\_common\-\_inclusion}.
+The
common inclusion entry has a
DW\-\_AT\-\_common\-\_reference attribute
whose value is a reference to the debugging information entry
If a subroutine explicitly declares that it may throw
an exception for one or more types, each such type is
represented by a debugging information entry with the tag
-DW\-\_TAG\-\_thrown\-\_type. Each such entry is a child of the entry
+\livetarg{chap:DWTAGthrowntype}{DW\-\_TAG\-\_thrown\-\_type}.
+Each such entry is a child of the entry
representing the subroutine that may throw this type. Each
thrown type entry contains a DW\-\_AT\-\_type attribute, whose
value is a reference to an entry describing the type of the
\begin{enumerate}[1.]
\item Each formal parameterized type declaration appearing in the
template definition is represented by a debugging information
-entry with the tag DW\-\_TAG\-\_template\-\_type\-\_parameter. Each
+entry with the
+tag \livetarg{chap:DWTAGtemplatetypeparameter}{DW\-\_TAG\-\_template\-\_type\-\_parameter}.
+Each
such entry has a DW\-\_AT\-\_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
\label{chap:concreteinlinedinstances}
Each inline expansion of a subroutine is represented
-by a debugging information entry with the tag
-DW\_TAG\_inlined\_subroutine. Each such entry should be a direct
+by a debugging information entry with the
+tag \livetarg{chap:DWTAGinlinedsubroutine}{DW\_TAG\_inlined\_subroutine}.
+Each such entry should be a direct
child of the entry that represents the scope within which
the inlining occurs.
blocks to any depth.}
A lexical block is represented by a debugging information
-entry with the tag DW\-\_TAG\-\_lexical\-\_block.
+entry with the
+tag \livetarg{chap:DWTAGlexicalblock}{DW\-\_TAG\-\_lexical\-\_block}.
The lexical block entry may have either a DW\_AT\_low\_pc and
DW\_AT\_high\_pc pair of attributes or a DW\_AT\_ranges attribute
statements.
A label is represented by a debugging information entry with
-the tag DW\_TAG\_label. The entry for a label should be owned by
+the
+tag \livetarg{chap:DWTAGlabel}{DW\_TAG\_label}.
+The entry for a label should be owned by
the debugging information entry representing the scope within
which the name of the label could be legally referenced within
the source program.
record variable.}
A with statement is represented by a debugging information
-entry with the tag DW\-\_TAG\-\_with\-\_stmt.
+entry with the tag \livetarg{chap:DWTAGwithstmt}{DW\-\_TAG\-\_with\-\_stmt}.
A with statement entry may have either a DW\_AT\_low\_pc and
DW\_AT\_high\_pc pair of attributes or a DW\_AT\_ranges attribute
can handle.}
A try block is represented by a debugging information entry
-with the tag DW\_TAG\_try\_block. A catch block is represented by
-a debugging information entry with the tag DW\_TAG\_catch\_block.
+with the tag \livetarg{chap:DWTAGtryblock}{DW\_TAG\_try\_block}.
+A catch block is represented by
+a debugging information entry with
+the tag \livetarg{chap:DWTAGcatchblock}{DW\_TAG\_catch\_block}.
Both try and catch block entries may have either a
DW\_AT\_low\_pc and DW\_AT\_high\_pc pair of attributes or a
\centering
\begin{tabular}{lp{9cm}}
Name&Meaning\\ \hline
-DW\_TAG\_const\_type & C or C++ const qualified type \\
-DW\_TAG\_packed\_type& Pascal or Ada packed type \\
-DW\_TAG\_pointer\_type & Pointer to an object of the type being modified \\
-DW\_TAG\_reference\_type& C++ (lvalue) reference to an object of the type
+\livetarg{chap:DWTAGconsttype}{DW\_TAG\_const\_type} & C or C++ const qualified type \\
+\livetarg{chap:DWTAGpackedtype}{DW\_TAG\_packed\_type}& Pascal or Ada packed type \\
+\livetarg{chap:DWTAGpointertype}{DW\_TAG\_pointer\_type} & Pointer to an object of the type being modified \\
+\livetarg{chap:DWTAGreferencetype}{DW\_TAG\_reference\_type}& C++ (lvalue) reference to an object of the type
being modified \\
-DW\_TAG\_restrict\_type&C restrict qualified type \\
-DW\_TAG\_rvalue\_reference\_type & C++ rvalue reference to an object of the type
+\livetarg{chap:DWTAGrestrictype}{DW\_TAG\_restrict\_type}&C restrict qualified type \\
+\livetarg{chap:DWTAGrvaluereferencetype}{DW\_TAG\_rvalue\_reference\_type} & C++ rvalue reference to an object of the type
being modified \\
-DW\_TAG\_shared\_type&UPC shared qualified type \\
-DW\_TAG\_volatile\_type&C or C++ volatile qualified type \\
+\livetarg{chap:DWTAGsharedtype}{DW\_TAG\_shared\_type}&UPC shared qualified type \\
+\livetarg{chap:DWTAGvolatiletype}{DW\_TAG\_volatile\_type}&C or C++ volatile qualified type \\
\end{tabular}
\caption{Type modifier tags}
\label{fig:typemodifiertags}
\label{chap:typedefentries}
A named type that is defined in terms of another type
definition is represented by a debugging information entry with
-the tag DW\_TAG\_typedef. The typedef entry has a DW\_AT\_name
+the tag \livetarg{chap:DWTAGtypedef}{DW\_TAG\_typedef}.
+The typedef entry has a DW\_AT\_name
attribute whose value is a null-terminated string containing
the name of the typedef as it appears in the source program.
a table of components of identical type.
An array type is represented by a debugging information entry
-with the tag DW\_TAG\_array\_type. If a name has been given to
+with the tag \livetarg{chap:DWTAGarraytype}{DW\_TAG\_array\_type}.
+If a name has been given to
the array type in the source program, then the corresponding
array type entry has a DW\_AT\_name attribute whose value is a
null-terminated string containing the array type name as it
Structure, union, and class types are represented by debugging
-information entries with the tags DW\_TAG\_structure\_type,
-DW\_TAG\_union\_type, and DW\_TAG\_class\_type,
+information entries with
+the tags \livetarg{chap:DWTAGstructuretype}{DW\_TAG\_structure\_type},
+\livetarg{chap:DWTAGuniontype}{DW\_TAG\_union\_type},
+and \livetarg{chap:DWTAGclasstype}{DW\_TAG\_class\_type},
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
methods and constant data members.}
Interface types are represented by debugging information
-entries with the tag DW\_TAG\_interface\_type.
+entries with the
+tag \livetarg{chap:DWTAGinterfacetype}{DW\_TAG\_interface\_type}.
An interface type entry has a DW\_AT\_name attribute, whose
value is a null-terminated string containing the type name
debugging information entries describing each of the classes
or interfaces it is derived from, extending or implementing,
respectively, ordered as they were in the source program. Each
-such entry has the tag DW\_TAG\_inheritance.
+such entry has the
+tag \livetarg{chap:DWTAGinheritance}{DW\_TAG\_inheritance}.
An inheritance entry has a DW\_AT\_type attribute whose value is
a reference to the debugging information entry describing the
Each ``friend'' declared by a structure, union or class
type may be represented by a debugging information entry
that is a child of the structure, union or class type entry;
-the friend entry has the tag DW\_TAG\_friend.
+the friend entry has the
+tag \livetarg{chap:DWTAGfriend}{DW\_TAG\_friend}.
A friend entry has a DW\_AT\_friend attribute, whose value is
a reference to the debugging information entry describing
\label{chap:datamemberentries}
A data member (as opposed to a member function) is
-represented by a debugging information entry with the tag
-DW\_TAG\_member. The member entry for a named member has
+represented by a debugging information entry with the
+tag \livetarg{chap:DWTAGmember}{DW\_TAG\_member}.
+The member entry for a named member has
a DW\_AT\_name attribute whose value is a null-terminated
string containing the member name as it appears in the source
program. If the member entry describes an anonymous union, the
\item Each formal parameterized value declaration appearing in the
template definition is represented by a debugging information
-entry with the tag DW\_TAG\_template\_value\_parameter. Each
+entry with the
+tag \livetarg{chap:DWTAGtemplatevalueparameter}{DW\_TAG\_template\_value\_parameter}.
+Each
such entry may have a DW\_AT\_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
\label{chap:variantentries}
A variant part of a structure is represented by a debugging
-information entry with the tag DW\_TAG\_variant\_part and is
+information entry with the
+tag \livetarg{chap:DWTAGvariantpart}{DW\_TAG\_variant\_part} and is
owned by the corresponding structure type entry.
If the variant part has a discriminant, the discriminant is
variable's value matches any of the described constants,
and the condition is ‛false’ otherwise.}
-The DW\_TAG\_condition debugging information entry describes a
+The \livetarg{chap:DWTAGcondition}{DW\_TAG\_condition} debugging information entry
+describes a
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
a fixed number of symbolic values.}
An enumeration type is represented by a debugging information
-entry with the tag DW\_TAG\_enumeration\_type.
+entry with the tag
+\livetarg{chap:DWTAGenumerationtype}{DW\_TAG\_enumeration\_type}.
If a name has been given to the enumeration type in the source
program, then the corresponding enumeration type entry has
with DW\_AT\_enum\_class.}
Each enumeration literal is represented by a debugging
-information entry with the tag DW\_TAG\_enumerator. Each
+information entry with the
+tag \livetarg{chap:DWTAGenumerator}{DW\_TAG\_enumerator}.
+Each
such entry is a child of the enumeration type entry, and the
enumerator entries appear in the same order as the declarations
of the enumeration literals in the source program.
(except for the name attribute).
A string type is represented by a debugging information entry
-with the tag DW\_TAG\_string\_type. If a name has been given to
+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 DW\_AT\_name attribute whose value is
a null\dash terminated string containing the string type name as
a group of values of ordinal type.}
A set is represented by a debugging information entry with
-the tag DW\_TAG\_set\_type. If a name has been given to the
+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 DW\_AT\_name attribute
whose value is a null\dash terminated string containing the
set type name as it appears in the source program.
A debugging information entry representing the type of an
object that is a pointer to a structure or class member has
-the tag DW\_TAG\_ptr\_to\_member\_type.
+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 DW\_AT\_name attribute, whose value is a
\begin{lstlisting}
object.*mbr_ptr
\end{lstlisting}
-
+% FIXME: object and mbr\_ptr should be distinguished from italic. See DW4.
\textit{where mbr\_ptr has some pointer to member type, a debugger should:}
\textit{1. Push the value of mbr\_ptr onto the DWARF expression stack.}
files.}
A file type is represented by a debugging information entry
-with the tag DW\_TAG\_file\_type. If the file type has a name,
+with the
+\livetarg{chap:DWTAGfiletype}{tag DW\_TAG\_file\_type}.
+If the file type has a name,
the file type entry has a DW\_AT\_name attribute, whose value
is a null\dash terminated string containing the type name as it
appears in the source program.
A type named using a template alias is represented
by a debugging information entry with the tag
-DW\-\_TAG\-\_template\-\_alias. The template alias entry has a
+\livetarg{chap:DWTAGtemplatealias}{DW\-\_TAG\-\_template\-\_alias}.
+The template alias entry has a
DW\-\_AT\-\_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
DWARF Git Projects / dwarf-doc.git / commitdiff