\end{alltt}
followed (or preceded, the order is not significant)
-by a series of section groups:
+by a series of
+\addtoindexx{section group}
+section groups:
\begin{alltt}
==== Section group 1
\addtoindex{.debug\_info}
\addtoindex{.debug\_line}
\end{alltt}
-where each section group might or might not contain executable
+where each \addtoindex{section group} might or might not contain executable
code (\textit{.text} sections) or data (\textit{.data} sections).
-A \textit{section group} is a named set of section contributions
+A \textit{\addtoindex{section group}} is a named set
+of section contributions
within an object file with the property that the entire set
of section contributions must be retained or discarded as a
whole; no partial elimination is allowed. Section groups can
\begin{enumerate}[1.]
\item Given multiple identical (duplicate) section groups,
+\addtoindexx{section group}
one of them is chosen to be kept and used, while the rest
are discarded.
-\item Given a section group that is not referenced from any
-section outside of the section group, the section group
+\item Given a \addtoindex{section group}
+that is not referenced from any
+section outside of the \addtoindex{section group},
+the section group
is discarded.
\end{enumerate}
-Which handling applies may be indicated by the section group
+Which handling applies may be indicated by the
+\addtoindex{section group}
itself and/or selection of certain linker options.
-For example, if a linker determines that section group 1
-from A.o and section group 3 from B.o are identical, it could
+For example, if a linker determines that
+\addtoindex{section group} 1
+from A.o and
+\addtoindex{section group} 3 from B.o are identical, it could
discard one group and arrange that all references in A.o and
B.o apply to the remaining one of the two identical section
groups. This saves space.
An important part of making it possible to “redirect”
-references to the surviving section group is the use of
+references to the surviving
+\addtoindex{section group} is the use of
consistently chosen linker global symbols for referring to
-locations within each section group. It follows that references
+locations within each
+\addtoindex{section group}.
+It follows that references
are simply to external names and the linker already knows
how to match up references and definitions.
\item A means of having multiple contributions to specific sections
(for example, \addtoindex{.debug\_info}, and so on) in a single object file.
-\item A means of identifying a section group (giving it a name).
+\item A means of identifying a \addtoindex{section group} (giving it a name).
\item A means of identifying which sections go together to make
-up a section group, so that the group can be treated as a unit
+up a \addtoindex{section group},
+so that the group can be treated as a unit
(kept or discarded).
-\item A means of indicating how each section group should be
+\item A means of indicating how each \addtoindex{section group} should be
processed by the linker.
\end{enumerate}
\textit{The notion of section and section contribution used here
corresponds closely to the similarly named concepts in the
-ELF object file representation. The notion of section group is
+ELF object file representation.
+The notion of \addtoindex{section group} is
an abstraction of common extensions of the ELF representation
widely known as ``COMDATs'' or ``COMDAT sections''. (Other
object file representations provide COMDAT\dash style mechanisms as
\textbf{Section Group Names}
-Section groups must have a section group name. For the subsequent
+Section groups must have a \addtoindex{section group} name.
+\addtoindexx{section group!name}
+For the subsequent
\addtoindex{C++} example, a name like
<producer-prefix>.<file-designator>.<gid-number>
\textless gid\dash number \textgreater
as a kind
of ``digital signature'' that allows a fast test for the
-equality of two section groups.}
+equality of two
+\addtoindexx{section group}
+section groups.}
-So, for example, the section group corresponding to file wa.h
+So, for example, the \addtoindex{section group}
+corresponding to file wa.h
above is given the name \textit{my.compiler.company.cpp.wa.h.123456}.
Global labels for
\addtoindexx{debugging information entry!ownership relation}
debugging information entries (need explained
-below) within a section group can be given names of the form
+below) within a \addtoindex{section group}
+can be given names of the form
\begin{alltt}
<prefix>.<file-designator>.<gid-number>.<die-number>
\end{itemize}
-In general, every point in the section group
+In general, every point in the
+\addtoindexx{section group}
+section group
\addtoindex{.debug\_info} that
could be referenced from outside by any compilation unit must
normally have an external name generated for it in the linker
\textless gid\dash number \textgreater
is generated.
-Note that only section groups that are designated as
+Note that only
+\addtoindexx{section group}
+section groups that are designated as
duplicate\dash removal\dash applies actually require the
\begin{alltt}
<prefix>.<file-designator>.<gid-number>.<die-number>
\end{alltt}
external labels for debugging information entries as all other
-section group sections can use 'local' labels
+\addtoindex{section group} sections can use 'local' labels
(section\dash relative
relocations).
\textbf{Use of \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit} versus
\livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit}}
-A section group compilation unit that uses
+A \addtoindex{section group} compilation unit that uses
\livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}
is like any other compilation unit, in that its contents
are evaluated by consumers as though it were an ordinary
are included into a procedure or module context.
Consequently a compiler must use \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} (instead
-of \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}) in a section group whenever the section
-group contents are not necessarily globally visible. This
+of \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit})
+in a \addtoindex{section group}
+whenever the section group
+contents are not necessarily globally visible.
+This
directs consumers to ignore that compilation unit when scanning
top level declarations and definitions.
unit's debugging information entries to those of another
compilation unit.
-When referencing into a removable section group
+When referencing into a removable \addtoindex{section group}
\addtoindex{.debug\_info}
from another \addtoindex{.debug\_info} (from anywhere), the
\begin{alltt}
name should be used for an external symbol and a relocation
generated based on that name.
-When referencing into a non-section group
+When referencing into a
+\addtoindexx{section group}
+non-section group
\addtoindex{.debug\_info},
from another \addtoindex{.debug\_info} (from anywhere)
\livelink{chap:DWFORMrefaddr}{DW\-\_FORM\-\_ref\-\_addr} is
information into sections (specifically the
\addtoindex{.debug\_info}
section) and the naming conventions used to achieve references
-into section groups. In practice, all of the examples that
+into
+\addtoindexx{section group}
+section groups.
+In practice, all of the examples that
follow involve DWARF sections other than just
\addtoindex{.debug\_info}
(for example, \addtoindex{.debug\_line},
section \refersec{app:duplicateeliminationexample1dwarfsectiongroup}
-shows the section group corresponding to the included file
+shows the \addtoindex{section group} corresponding to the included file
wa.h.
Figure \refersec{app:duplicateeliminationexample1primarycompilationunit}
shows the ``normal'' DWARF sections, which are not part of
-any section group, and how they make use of the information
-in the section group shown above.
+any \addtoindex{section group},
+and how they make use of the information
+in the \addtoindex{section group} shown above.
\paragraph{Duplicate elimination example 1: primary compilation unit}
\label{app:duplicateeliminationexample1primarycompilationunit}
...
\end{alltt}
-This example uses \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit} for the section group,
+This example uses \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit} for the \addtoindex{section group},
implying that the contents of the compilation unit are
globally visible (in accordance with
\addtoindex{C++} language rules).
Section \refersec{app:duplicateeliminationexample2dwarfsectiongroup}
-shows the section group
+shows the \addtoindex{section group}
corresponding to the included file
\addtoindexx{Fortran example}
CommonStuff.fh.
\end{lstlisting}
That main program results in an object file that
-contained a duplicate of the section group named
+contained a duplicate of the \addtoindex{section group} named
my.f90.company.f90.CommonStuff.fh.654321
corresponding to the
included file as well as the remainder of the main subprogram
\end{alltt}
-This example uses \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} for the section group
+This example uses \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} for the \addtoindex{section group}
because the included declarations are not independently
visible as global entities.
in the primary unit
(see Figure \refersec{app:duplicateeliminationexample1primarycompilationunit})
with an \livelink{chap:DWATimport}{DW\-\_AT\-\_import} attribute that refers to the proper unit
-in the section group.
+in the \addtoindex{section group}.
\textit{The \addtoindex{C} rules for consistency of global (file scope) symbols
across compilations are less strict than for C++; inclusion
of the import unit attribute assures that the declarations of
-the proper section group are considered before declarations
+the proper \addtoindex{section group} are considered before declarations
from other compilations.}
linkers today support the concept of a COMDAT group or
linkonce section. The general idea is that a ``key'' can be
attached to a section or a group of sections, and the linker
-will include only one copy of a section group (or individual
-section) for any given key. For
+will include only one copy of a \addtoindex{section group}
+(or individual section) for any given key.
+For
\addtoindex{.debug\_types} sections, the
key is the type signature formed from the algorithm given in
Section \refersec{datarep:typesignaturecomputation}.
duplication.
A reasonable approach is to put each header file in its own
-section group, using the naming rules mentioned above. The
+\addtoindex{section group}, using the naming rules mentioned above. The
section groups are marked to ensure duplicate removal.
All data instances and code instances (even if they came
-from the header files above) are put into non-section group
+from the header files above) are put
+\addtoindexx{section group}
+into non-section group
sections such as the base object file
\addtoindex{.debug\_info} section.
For each such code group (function template in this example)
the compiler assigns a name for the group which will match
all other instantiations of this function but match nothing
-else. The section groups are marked to ensure duplicate
+else.
+The
+\addtoindexx{section group}
+section groups are marked to ensure duplicate
removal, so that the second and subsequent definitions seen
by the static linker are simply discarded.
Section groups can help make it easy for a linker to completely
remove unused functions.
-Such section groups are not marked for duplicate removal,
+Such
+\addtoindexx{section group}
+section groups are not marked for duplicate removal,
since the functions are not duplicates of anything.
Each function is given a compilation unit and a section
Section groups can use \livelink{chap:DWFORMrefaddr}{DW\-\_FORM\-\_ref\-\_addr} and internal labels
(section\dash relative relocations) to refer to the main object
-file sections, as the section groups here are either deleted
+file sections, as the
+\addtoindexx{section group}
+section groups here are either deleted
as unused or kept. There is no possibility (aside from error)
of a group from some other compilation being used in place
of one of these groups.
\addtoindexx{abstract instance}
\addtoindexx{concrete out-of-line instance}
and concrete-out-of-line instances may be
-put in distinct compilation units using section groups. This
+put in distinct compilation units using
+\addtoindexx{section group}
+section groups.
+This
makes possible some useful duplicate DWARF elimination.
\textit{No special provision for eliminating class duplication
specified modifies the location specified by the defining declaration and only applies for the
scope of the variable entry; if no location is specified, then the location specified in the
defining declaration applies.
-The location of a variable may be further specified with a \livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} attribute, if
+The location of a variable may be further specified with
+\addtoindexx{segment attribute!and data segment}
+a
+\livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} attribute, if
appropriate.
\item A \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute describing the type of the variable,
formal parameter of an inlined subprogram that corresponds
to a constant actual parameter of a call that is inlined.
-\item A \livelink{chap:DWATstartscope}{DW\-\_AT\-\_start\-\_scope} attribute if the scope of an
+\item A \livelink{chap:DWATstartscope}{DW\-\_AT\-\_start\-\_scope} attribute if the scope of
+\addtoindexx{start scope attribute}
+an
\hypertarget{chap:DWATstartscopeobjectdeclaration}
object is smaller than (that is, is a subset of the addresses
of) the scope most closely enclosing the object. There are
\addtoindexx{reserved values!initial length}
An \addtoindex{initial length field} is one of the length fields that occur
-at the beginning of those DWARF sections that have a header
+at the beginning
+of those DWARF sections that
+have a header
(\addtoindex{.debug\_aranges},
\addtoindex{.debug\_info},
\addtoindex{.debug\_types},
detect that a DWARF section contribution is using the 64\dash bit
format and to adapt its processing accordingly.}
-\item Section offset and section length fields that occur
+\item Section offset and section length
+\addtoindexx{section length!use in headers}
+fields that occur
+\addtoindexx{section offset!use in headers}
in the headers of DWARF sections (other
\addtoindex{initial length field}
than
\addtoindex{initial length}
fields) are listed following. In the 32\dash bit DWARF format these
are 32\dash bit unsigned integer values; in the 64\dash bit DWARF format,
-they are 64\dash bit unsigned integer values.
+they
+\addtoindexx{section length!in .debug\_aranges header}
+are
+\addtoindexx{section length!in .debug\_pubnames header}
+64\dash bit
+\addtoindexx{section length!in .debug\_pubtypes header}
+unsigned integer values.
\begin{center}
\begin{tabular}{lll}
The value in this field is 4.
\item \addtoindex{debug\_abbrev\_offset} (section offset) \\
-A 4\dash byte or 8\dash byte unsigned offset into the
+A
+\addtoindexx{section offset!in .debug\_info header}
+4\dash byte or 8\dash byte unsigned offset into the
\addtoindex{.debug\_abbrev}
section. This offset associates the compilation unit with a
particular set of debugging information entry abbreviations. In
The value in this field is 4.
\item \addtoindex{debug\_abbrev\_offset} (section offset) \\
-A 4\dash byte or 8\dash byte unsigned offset into the
+A
+\addtoindexx{section offset!in .debug\_types header}
+4\dash byte or 8\dash byte unsigned offset into the
\addtoindex{.debug\_abbrev}
section. This offset associates the compilation unit with a
particular set of debugging information entry abbreviations. In
(see Section \refersec{datarep:32bitand64bitdwarfformats}).
\item address\_size (ubyte) \\
-A 1\dash byte unsigned integer representing the size in bytes of
+A 1\dash byte unsigned integer representing the size
+\addtoindexx{size of an address}
+in bytes of
\addtoindexx{address\_size}
an address on the target architecture. If the system uses
\addtoindexx{address space!segmented}
\item type\_offset (section offset) \\
-A 4\dash byte or 8\dash byte unsigned offset relative to the beginning
+A 4\dash byte or 8\dash byte unsigned offset
+\addtoindexx{section offset!in .debug\_types header}
+relative to the beginning
of the type unit header. This offset refers to the debugging
information entry that describes the type. Because the type
may be nested inside a namespace or other structures, and may
no value is encoded in the debugging information entry itself.
\item \livelink{chap:lineptr}{lineptr} \\
-This is an offset into the
+This is an offset into
+\addtoindexx{section offset!in class lineptr value}
+the
\addtoindex{.debug\_line} section
-(\livelink{chap:DWFORMsecoffset}{DW\-\_FORM\-\_sec\-\_offset}). It consists of an offset from the
+(\livelink{chap:DWFORMsecoffset}{DW\-\_FORM\-\_sec\-\_offset}).
+It consists of an offset from the
beginning of the
\addtoindex{.debug\_line}
section to the first byte of
This is an offset into the
\addtoindex{.debug\_loc}
section
-(\livelink{chap:DWFORMsecoffset}{DW\-\_FORM\-\_sec\-\_offset}). It consists of an offset from the
+(\livelink{chap:DWFORMsecoffset}{DW\-\_FORM\-\_sec\-\_offset}).
+It consists of an offset from the
+\addtoindexx{section offset!in class loclistptr value}
beginning of the
\addtoindex{.debug\_loc}
section to the first byte of
\item \livelink{chap:macptr}{macptr} \\
-This is an offset into the
+This is an
+\addtoindexx{section offset!in class macptr value}
+offset into the
\addtoindex{.debug\_macinfo} section
(\livelink{chap:DWFORMsecoffset}{DW\-\_FORM\-\_sec\-\_offset}). It consists of an offset from the
beginning of the \addtoindex{.debug\_macinfo}
(see Section \refersec{datarep:32bitand64bitdwarfformats}).
\item \livelink{chap:rangelistptr}{rangelistptr} \\
-This is an offset into the \addtoindex{.debug\_ranges} section
+This is an
+\addtoindexx{section offset!in class rangelistptr value}
+offset into the \addtoindex{.debug\_ranges} section
(\livelink{chap:DWFORMsecoffset}{DW\-\_FORM\-\_sec\-\_offset}).
It consists of an
offset from the beginning of the
The
\addtoindexx{reference class}
first type of reference can identify any debugging
-information entry within the containing unit. This type of
-reference is an offset from the first byte of the compilation
+information entry within the containing unit.
+This type of
+reference is an
+\addtoindexx{section offset!in class reference value}
+offset from the first byte of the compilation
header for the compilation unit containing the reference. There
are five forms for this type of reference. There are fixed
length forms for one, two, four and eight byte offsets
\item string \\
A string is a sequence of contiguous non\dash null bytes followed by
-one null byte. A string may be represented immediately in the
+one null byte.
+\addtoindexx{string class}
+A string may be represented immediately in the
debugging information entry itself
(\livetarg{chap:DWFORMstring}{DW\-\_FORM\-\_string}), or may
-be represented as an offset into a string table contained in
+be represented as an
+\addtoindexx{section offset!in class string value}
+offset into a string table contained in
the \addtoindex{.debug\_str} section of the object file
(\livetarg{chap:DWFORMstrp}{DW\-\_FORM\-\_strp}). In
the 32\dash bit DWARF format, the representation of a
The value in this field is 4.
% Some say unsigned offset this just says offset: FIXME
-\item debug\_info\_offset (section offset) \\
-A 4\dash byte or 8\dash byte offset into the
+\item \addtoindex{debug\_info\_offset} (section offset) \\
+A
+\addtoindexx{section offset!in name lookup table set of entries}
+4\dash byte or 8\dash byte
+offset into the
\addtoindex{.debug\_info}
section of the compilation unit header.
In
in the 64\dash bit DWARF format, this is an 8\dash byte unsigned offsets
(see Section \refersec{datarep:32bitand64bitdwarfformats}).
-\item debug\_info\_length (section length) \\
-A 4\dash byte or 8\dash byte length containing the size in bytes of the
+\item \addtoindex{debug\_info\_length} (section length) \\
+\addtoindexx{section length!in .debug\_pubnames header}
+A
+\addtoindexx{section length!in .debug\_pubtypes header}
+4\dash byte or 8\dash byte length containing the size in bytes of the
contents of the \addtoindex{.debug\_info}
section generated to represent
this compilation unit. In the 32\dash bit DWARF format, this is
(see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
\item debug\_info\_offset (section offset) \\
-A 4\dash byte or 8\dash byte offset into the
+A
+\addtoindexx{section offset!in .debug\_aranges header}
+4\dash byte or 8\dash byte offset into the
\addtoindex{.debug\_info} section of
the compilation unit header. In the 32\dash bit DWARF format,
this is a 4\dash byte unsigned offset; in the 64\dash bit DWARF format,
\item address\_size (ubyte) \\
A 1\dash byte unsigned integer containing the size in bytes of an
\addtoindexx{address\_size}
-address (or the offset portion of an address for segmented
+address
+\addtoindexx{size of an address}
+(or the offset portion of an address for segmented
\addtoindexx{address space!segmented}
addressing) on the target system.
\item segment\_size (ubyte) \\
-A 1\dash byte unsigned integer containing the size in bytes of a
+A
+\addtoindexx{segment\_size}
+1\dash byte unsigned integer containing the size in bytes of a
segment selector on the target system.
\end{enumerate}
This header is followed by a series of tuples. Each tuple
consists of a segment, an address and a length.
The segment
-size is given by the segment\_size field of the header; the
+size is given by the \addtoindex{segment\_size} field of the header; the
address and length size are each given by the address\_size
field of the header.
The first tuple following the header in
each set begins at an offset that is a multiple of the size
of a single tuple (that is, the size of a segment selector
-plus twice the size of an address).
+plus twice the \addtoindex{size of an address}).
The header is padded, if
necessary, to that boundary. Each set of tuples is terminated
by a 0 for the segment, a 0 for the address and 0 for the
-length. If the segment\_size field in the header is zero,
+length. If the \addtoindex{segment\_size} field in the header is zero,
the segment selectors are omitted from all tuples, including
the terminating tuple.
32\dash bit addresses, an assembler or compiler must provide a way
to produce 2\dash byte and 4\dash byte quantities without alignment
restrictions, and the linker must be able to relocate a
-4\dash byte address or section offset that occurs at an arbitrary
+4\dash byte address or
+\addtoindexx{section offset!alignment of}
+section offset that occurs at an arbitrary
alignment.
\item For the 32\dash bit DWARF format and a target architecture with
64\dash bit addresses, an assembler or compiler must provide a
way to produce 2\dash byte, 4\dash byte and 8\dash byte quantities without
alignment restrictions, and the linker must be able to relocate
-an 8\dash byte address or 4\dash byte section offset that occurs at an
+an 8\dash byte address or 4\dash byte
+\addtoindexx{section offset!alignment of}
+section offset that occurs at an
arbitrary alignment.
\item For the 64\dash bit DWARF format and a target architecture with
32\dash bit addresses, an assembler or compiler must provide a
way to produce 2\dash byte, 4\dash byte and 8\dash byte quantities without
alignment restrictions, and the linker must be able to relocate
-a 4\dash byte address or 8\dash byte section offset that occurs at an
+a 4\dash byte address or 8\dash byte
+\addtoindexx{section offset!alignment of}
+section offset that occurs at an
arbitrary alignment.
\textit{It is expected that this will be required only for very large
64\dash bit addresses, an assembler or compiler must provide a
way to produce 2\dash byte, 4\dash byte and 8\dash byte quantities without
alignment restrictions, and the linker must be able to
-relocate an 8\dash byte address or section offset that occurs at
+relocate an 8\dash byte address or
+\addtoindexx{section offset!alignment of}
+section offset that occurs at
an arbitrary alignment.
\end{itemize}
\hline
\endlastfoot
-sbyte& signed, 1\dash byte integer \\
-ubyte&unsigned, 1\dash byte integer \\
-uhalf&unsigned, 2\dash byte integer \\
-uword&unsigned, 4\dash byte integer \\
+\addtoindex{sbyte}& signed, 1\dash byte integer \\
+\addtoindex{ubyte}&unsigned, 1\dash byte integer \\
+\addtoindex{uhalf}&unsigned, 2\dash byte integer \\
+\addtoindex{uword}&unsigned, 4\dash byte integer \\
\end{longtable}
\end{centering}
\hypertarget{chap:DWATsiblingdebugginginformationentryrelationship}
it will be important for consumers of that information to
quickly scan chains of sibling entries, while ignoring the
-children of individual siblings, that producer may attach a
-\livelink{chap:DWATsibling}{DW\-\_AT\-\_sibling} attribute to any debugging information entry.
+children of individual siblings, that producer may attach
+\addtoindexx{sibling attribute}
+a
+\livelink{chap:DWATsibling}{DW\-\_AT\-\_sibling} attribute
+to any debugging information entry.
The
value of this attribute is a reference to the sibling entry
of the entry to which the attribute is attached.
For example, if a particular target architecture supports
both 32\dash bit and 64\dash bit addresses, the compiler will generate
an object file which specifies that it contains executable
-code generated for one or the other of these address sizes. In
+code generated for one or the other of these
+\addtoindexx{size of an address}
+address sizes. In
that case, the DWARF debugging information contained in this
object file will use the same address size.
}
\label{chap:generaloperations}
Each general operation represents a postfix operation on
a simple stack machine. Each element of the stack is the
-size of an address on the target machine. The value on the
+\addtoindex{size of an address} on the target machine.
+The value on the
top of the stack after ``executing'' the
\addtoindex{DWARF expression}
is
\item \livetarg{chap:DWOPaddr}{DW\-\_OP\-\_addr} \\
The \livelink{chap:DWOPaddr}{DW\-\_OP\-\_addr} operation has a single operand that encodes
-a machine address and whose size is the size of an address
+a machine address and whose size is the \addtoindex{size of an address}
on the target machine.
\item \livetarg{chap:DWOPconst1u}{DW\-\_OP\-\_const1u}, \livetarg{chap:DWOPconst2u}{DW\-\_OP\-\_const2u}, \livetarg{chap:DWOPconst4u}{DW\-\_OP\-\_const4u}, \livetarg{chap:DWOPconst8u}{DW\-\_OP\-\_const8u} \\
retrieved from that address is pushed.
The size of the data retrieved from the
\addtoindexi{dereferenced}{address!dereference operator}
-address is the size of an address on the target machine.
+address is the \addtoindex{size of an address} on the target machine.
\item \livetarg{chap:DWOPderefsize}{DW\-\_OP\-\_deref\-\_size} \\
The \livelink{chap:DWOPderefsize}{DW\-\_OP\-\_deref\-\_size} operation behaves like the \livelink{chap:DWOPderef}{DW\-\_OP\-\_deref}
of the data retrieved from the dereferenced address is
specified by the single operand. This operand is a 1\dash byte
unsigned integral constant whose value may not be larger
-than the size of an address on the target machine. The data
+than the \addtoindex{size of an address} on the target machine. The data
retrieved is zero extended to the size of an address on the
target machine before being pushed onto the expression stack.
of the data retrieved from the
\addtoindexi{dereferenced}{address!dereference operator}
address is the
-size of an address on the target machine.
+\addtoindex{size of an address} on the target machine.
\item \livetarg{chap:DWOPxderefsize}{DW\-\_OP\-\_xderef\-\_size}\\
The \livelink{chap:DWOPxderefsize}{DW\-\_OP\-\_xderef\-\_size} operation behaves like the
\addtoindexi{dereferenced}{address!dereference operator}
address is specified by the single operand. This operand is a
1\dash byte unsigned integral constant whose value may not be larger
-than the size of an address on the target machine. The data
-retrieved is zero extended to the size of an address on the
+than the \addtoindex{size of an address} on the target machine. The data
+retrieved is zero extended to the \addtoindex{size of an address} on the
target machine before being pushed onto the expression stack.
\item \livetarg{chap:DWOPpushobjectaddress}{DW\-\_OP\-\_push\-\_object\-\_address}\\
as otherwise specified, the arithmetic operations perfom
addressing arithmetic, that is, unsigned arithmetic that is
performed modulo one plus the largest representable address
-(for example, 0x100000000 when the size of an address is 32
-bits). Such operations do not cause an exception on overflow.
+(for example, 0x100000000 when the
+\addtoindex{size of an address} is 32
+bits).
+Such operations do not cause an exception on overflow.
\begin{enumerate}[1]
\item \livetarg{chap:DWOPabs}{DW\-\_OP\-\_abs} \\
\item \textit{Single location descriptions},
which
\addtoindexx{location description!single}
-are a language independent representation of
+are
+\addtoindexx{single location description}
+a language independent representation of
addressing rules of arbitrary complexity built from
DWARF expressions (See Section \refersec{chap:dwarfexpressions})
and/or other
\begin{enumerate}[1]
\item A simple location description, representing an object
\addtoindexx{location description!simple}
-which exists in one contiguous piece at the given location, or
+which
+\addtoindexx{simple location description}
+exists in one contiguous piece at the given location, or
\item A composite location description consisting of one or more
\addtoindexx{location description!composite}
simple location descriptions, each of which is followed by
\begin{enumerate}[1]
\item \livetarg{chap:DWOPpiece}{DW\-\_OP\-\_piece} \\
-The \livelink{chap:DWOPpiece}{DW\-\_OP\-\_piece} operation takes a single operand, which is an
+The \livelink{chap:DWOPpiece}{DW\-\_OP\-\_piece} operation takes a
+single operand, which is an
unsigned LEB128 number. The number describes the size in bytes
of the piece of the object referenced by the preceding simple
location description. If the piece is located in a register,
\begin{enumerate}[1]
\item A beginning address offset.
-This address offset has the size of an address and is
+This address offset has the \addtoindex{size of an address} and is
relative to the applicable base address of the compilation
unit referencing this location list. It marks the beginning
of the address
over which the location is valid.
\item An ending address offset. This address offset again
-has the size of an address and is relative to the applicable
+has the \addtoindex{size of an address} and is relative to the applicable
base address of the compilation unit referencing this location
list. It marks the first address past the end of the address
range over which the location is valid. The ending address
because the size of the range covered by such
an entry is zero.}
-\item A single location description
+\item A \addtoindex{single location description}
describing the location of the object over the range specified by
the beginning and end addresses.
\end{enumerate}
\textit{In some systems, addresses are specified as offsets within a
given
\addtoindexx{address space!segmented}
-segment rather than as locations within a single flat
+segment
+\addtoindexx{segmented adddressing|see{address space}}
+rather than as locations within a single flat
\addtoindexx{address space!flat}.
address space.}
\hypertarget{chap:DWATsegmentaddressinginformation}
of the location of an object or subroutine may have
a
-\livelink{chap:DWATsegment}{DW\-\_AT\-\_segment}
-attribute, whose value is a location
+\livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} attribute,
+\addtoindexx{segment attribute}
+whose value is a location
description. The description evaluates to the segment selector
of the item being described. If the entry containing the
\livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} attribute has a
a location
description that evaluates to an address, then those address
values represent the offset portion of the address within
-the segment specified by \livelink{chap:DWATsegment}{DW\-\_AT\-\_segment}.
+the segment specified
+\addtoindexx{segment attribute}
+by \livelink{chap:DWATsegment}{DW\-\_AT\-\_segment}.
-If an entry has no \livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} attribute, it inherits
+If an entry has no
+\livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} attribute, it inherits
+\addtoindexx{segment attribute}
the segment value from its parent entry. If none of the
entries in the chain of parents for this entry back to
-its containing compilation unit entry have \livelink{chap:DWATsegment}{DW\-\_AT\-\_segment}
-attributes, then the entry is assumed to exist within a flat
-address space. Similarly, if the entry has a \livelink{chap:DWATsegment}{DW\-\_AT\-\_segment}
-attribute containing an empty location description, that
+its containing compilation unit entry have
+\livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} attributes,
+then the entry is assumed to exist within a flat
+address space.
+Similarly, if the entry has a
+\livelink{chap:DWATsegment}{DW\-\_AT\-\_segment} attribute
+\addtoindexx{segment attribute}
+containing an empty location description, that
entry is assumed to exist within a
\addtoindexi{flat}{address space!flat}.
address space.
\livelink{chap:DWATsibling}{DW\-\_AT\-\_sibling} and
\livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration}
\addtoindexx{declaration attribute}
-clearly cannot apply to a referring
+clearly cannot apply to a
+\addtoindexx{declaration attribute}
+referring
+\addtoindexx{sibling attribute}
entry.}
In addition, a non-contiguous range of
addresses may also be specified for the
\livelink{chap:DWATstartscope}{DW\-\_AT\-\_start\-\_scope} attribute.
+\addtoindexx{start scope attribute}
If an entity has no associated machine code,
none of these attributes are specified.
whose value is of class \livelink{chap:rangelistptr}{rangelistptr}
and indicates the beginning of a \addtoindex{range list}.
Similarly,
-a \livelink{chap:DWATstartscope}{DW\-\_AT\-\_start\-\_scope} attribute may have a value of class
+a \livelink{chap:DWATstartscope}{DW\-\_AT\-\_start\-\_scope} attribute
+\addtoindexx{start scope attribute}
+may have a value of class
\livelink{chap:rangelistptr}{rangelistptr} for the same reason.
Range lists are contained
A \addtoindex{range list} entry consists of:
\begin{enumerate}[1]
-\item A beginning address offset. This address offset has the size of an address and is relative to
+\item A beginning address offset. This address offset has the
+\addtoindex{size of an address} and is relative to
the applicable base address of the compilation unit referencing this
\addtoindex{range list}.
It marks the
\addtoindexi{address}{address range!in range list}
range.
-\item An ending address offset. This address offset again has the size of an address and is relative
+\item An ending address offset. This address offset again has the
+\addtoindex{size of an address} and is relative
to the applicable base address of the compilation unit referencing
this \addtoindex{range list}.
It marks the
name) from DWARF expressions, which compute a final value (such as an array bound).
\item Add support for bundled instructions on machine architectures where instructions do not
occupy a whole number of bytes.
-\item Add a new attribute form for section offsets, \livelink{chap:DWFORMsecoffset}{DW\-\_FORM\-\_sec\-\_offset}, to replace the use
+\item Add a new attribute form for
+section offsets, \livelink{chap:DWFORMsecoffset}{DW\-\_FORM\-\_sec\-\_offset},
+\addtoindexx{section offset}
+to replace the use
of \livelink{chap:DWFORMdata4}{DW\-\_FORM\-\_data4} and \livelink{chap:DWFORMdata8}{DW\-\_FORM\-\_data8} for section offsets.
\item Add an attribute, \livelink{chap:DWATmainsubprogram}{DW\-\_AT\-\_main\-\_subprogram}, to identify the main subprogram of a
program.
In the descriptions that follow, these terms are used to
specify the representation of DWARF sections:
-Initial length, section offset and section length, which are
+Initial length, section offset and
+\addtoindex{section length}, which are
defined in
Sections \refersec{datarep:locationdescriptions} and
\refersec{datarep:32bitand64bitdwarfformats}.
-Sbyte, ubyte, uhalf, and uword, which are defined in
+Sbyte,
+\addtoindex{ubyte},
+\addtoindex{uhalf}, and
+\addtoindex{uword},
+which
+\addtoindexx{sbyte}
+are defined in
Section \refersec{datarep:integerrepresentationnames}.
\section{Accelerated Access}
(see Section \refersec{datarep:locationdescriptions}).
\item version (uhalf) \\
-A version number\addtoindexx{version number!name lookup table}\addtoindexx{version number!type lookup table}
+A version number
+\addtoindexx{version number!name lookup table}
+\addtoindexx{version number!type lookup table}
(see Section \refersec{datarep:namelookuptables}).
This number is specific
to the name lookup table and is independent of the DWARF
version number.
\item debug\_info\_offset (section offset) \\
-The offset from the beginning of the
+The
+\addtoindexx{section offset!in .debug\_pubtypes header}
+offset
+\addtoindexx{section offset!in .debug\_pubtypes header}
+from the beginning of the
\addtoindex{.debug\_info} section of
the compilation unit header referenced by the set.
\item debug\_info\_length (section length) \\
-The size in bytes of the contents of the
+\addtoindexx{section length!in .debug\_pubnames header}
+The
+\addtoindexx{section length!in .debug\_pubtypes header}
+size in bytes of the contents of the
\addtoindex{.debug\_info} section
generated to represent that compilation unit.
\end{enumerate}
\item debug\_info\_offset (section offset) \\
The offset from the
+\addtoindexx{section offset!in .debug\_pubnames header}
beginning of the \addtoindex{.debug\_info} or
\addtoindex{.debug\_types} section of the
compilation unit header referenced by the set.
\item address\_size (ubyte) \\
-The size of an address in bytes on
+The \addtoindex{size of an address}
+in
+\addtoindexx{ubyte}
+bytes on
\addtoindexx{address\_size}
the target architecture. For
\addtoindexx{address space!segmented}
the size of the offset portion of the address.
\item segment\_size (ubyte) \\
-The size of a segment selector in
+The size of a segment selector
+\addtoindexx{ubyte}
+in
+\addtoindexx{segment\_size}
bytes on the target architecture. If the target system uses
a flat address space, this value is 0.
of a range of text or data covered by some entry owned by
the corresponding compilation unit, followed by the non\dash zero
length of that range. A particular set is terminated by an
-entry consisting of three zeroes. When the segment\_size value
+entry consisting of three zeroes.
+When the
+\addtoindex{segment\_size} value
is zero in the header, the segment selector is omitted so that
each descriptor is just a pair, including the terminating
entry. By scanning the table, a debugger can quickly decide
be either ``true'' or ``false''. This approach might be
used as part of support for debugging optimized code.}
-\item line\_base (sbyte) \\
+\item line\_base (\addtoindex{sbyte}) \\
\addtoindexx{line\_base}
This parameter affects the meaning of the special opcodes. See below.
\item line\_range (ubyte) \\
\addtoindexx{line\_range}
-This parameter affects the meaning of the special opcodes. See below.
+This
+\addtoindexx{ubyte}
+parameter affects the meaning of the special opcodes. See below.
\item opcode\_base (ubyte) \\
The
\addtoindex{opcode\_base}
-number assigned to the first special opcode.
+number
+\addtoindexx{ubyte}
+ assigned to the first special opcode.
\textit{Opcode base is typically one greater than the highest-numbered
\addtoindex{opcode\_base}
The size of a target address
\addtoindexx{address\_size}
in this CIE and any FDEs that
+\addtoindexx{ubyte}
use it, in bytes. If a compilation unit exists for this frame,
its address size must match the address size here.
\item segment\_size (ubyte) \\
-The size of a segment selector in this CIE and any FDEs that
+The
+\addtoindexx{segment\_size}
+size
+\addtoindexx{ubyte}
+of a segment selector in this CIE and any FDEs that
use it, in bytes.
\item \addtoindex{code\_alignment\_factor} (unsigned LEB128) \\
address size.
\item CIE\_pointer (4 or 8 bytes, see Section \refersec{datarep:32bitand64bitdwarfformats}) \\
-A constant offset into the \addtoindex{.debug\_frame}
+A constant
+\addtoindexx{section offset!in FDE header}
+offset into the \addtoindex{.debug\_frame}
section that denotes
the CIE that is associated with this FDE.
\item initial\_location (segment selector and target address) \\
-The address of the first location associated with this table
-entry. If the segment\_size field of this FDE's CIE is non-zero,
+The
+\addtoindexx{initial\_location}
+address of the first location associated with this table
+entry.
+If the \addtoindex{segment\_size} field of this FDE's CIE is non-zero,
the initial location is preceded by a segment selector of
the given length.
\item address\_range (target address) \\
-The number of bytes of program instructions described by this entry.
+The
+\addtoindexx{address\_range}
+number
+\addtoindexx{target address}
+of bytes of program instructions described by this entry.
\item instructions (array of ubyte) \\
-A sequence of table defining instructions that are described below.
+A
+\addtoindexx{ubyte}
+sequence of table defining instructions that are described below.
\item 6. padding (array of ubyte) \\
-Enough \livelink{chap:DWCFAnop}{DW\-\_CFA\-\_nop} instructions to make the size of this
+Enough \livelink{chap:DWCFAnop}{DW\-\_CFA\-\_nop} instructions
+to make the size of this
+\addtoindexx{ubyte}
entry match the length value above.
\end{enumerate}
\begin{enumerate}[1.]
\item \textbf{DW\-\_CFA\-\_set\-\_loc} \\
-The \livetarg{chap:DWCFAsetloc}{DW\-\_CFA\-\_set\-\_loc} instruction takes a single operand that
+The \livetarg{chap:DWCFAsetloc}{DW\-\_CFA\-\_set\-\_loc} instruction
+takes a single operand that
represents a target address. The required action is to create a
new table row using the specified address as the location. All
other values in the new row are initially identical to the
current row. The new location value is always greater than
-the current one. If the segment\_size field of this FDE's CIE
+the current one.
+If the \addtoindex{segment\_size} field of this FDE's
+\addtoindex{CIE}
is non- zero, the initial location is preceded by a segment
selector of the given length.
\end{tabular}
\end{figure}
-\item A \livelink{chap:DWATstmtlist}{DW\-\_AT\-\_stmt\-\_list} attribute whose value is a section
+\item A \livelink{chap:DWATstmtlist}{DW\-\_AT\-\_stmt\-\_list} attribute whose value is
+\addtoindexx{statement list attribute}
+a
+\addtoindexx{section offset!in statement list attribute}
+section
\hypertarget{chap:DWATstmtlistlinenumberinformationforunit}
-offset to the line number information for this compilation
+offset
+to the line number information for this compilation
unit. This information is placed in a separate object file
section from the debugging information entries themselves. The
value of the statement list attribute is the offset in the
\item A \livelink{chap:DWATmacroinfo}{DW\-\_AT\-\_macro\-\_info} attribute
\addtoindex{macro information attribute}
-whose value is a section
+whose value is a
+\addtoindexx{section offset!in macro information attribute}
+section
\hypertarget{chap:DWATmacroinfomacroinformation}
offset to the macro information for this compilation unit.
This information is placed in a separate object file section
defined outside of the body of the namespace declaration,
that type, variable, or function definition entry has a
\livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} attribute
+\addtoindexx{specification attribute}
whose value is a reference to the
debugging information entry representing the declaration of
the type, variable or function. Type, variable, or function
-entries with a \livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} attribute do not need
+entries with a
+\livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} attribute
+\addtoindexx{specification attribute}
+do not need
to duplicate information provided by the declaration entry
referenced by the specification attribute.
\addtoindexx{function entry|see{subroutine entry}}
for
\addtoindexx{subroutine entry}
-subroutines and entry
+subroutines
+\addtoindexx{subprogram entry}
+and entry
% FIXME: is entry point entry the right index 'entry'?
\addtoindexx{entry point entry}
points:
described in Section \refersec{chap:linkagenames}.
If the name of the subroutine described by an entry with the
+\addtoindex{subprogram entry}
tag \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}
is visible outside of its containing
\hypertarget{chap:DWATexternalexternalsubroutine}
template definition, but does represent each instantiation.}
A template instantiation is represented by a debugging
-information entry with the tag \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}. With four
+information entry with the
+\addtoindexx{subprogram entry!use for template instantiation}
+tag \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}. With four
exceptions, such an entry will contain the same attributes and
will have the same types of child entries as would an entry
for a subroutine defined explicitly using the instantiation
is represented by a debugging information entry with the
tag
\livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}.
-The entry for a subroutine that is
+The entry for a
+\addtoindexx{subprogram entry!use in inlined subprogram}
+subroutine that is
\hypertarget{chap:DWATinlineinlinedsubroutine}
explicitly declared to be available for inline expansion or
that was expanded inline implicitly by the compiler has
Each abstract instance root is either part of a larger
\addtoindexx{abstract instance!root}
-tree (which gives a context for the root) or uses
-\livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} to refer to the declaration in context.
+tree (which gives a context for the root) or
+\addtoindexx{specification attribute}
+uses
+\livelink{chap:DWATspecification}{DW\-\_AT\-\_specification}
+to refer to the declaration in context.
\textit{For example, in \addtoindex{C++} the context might be a namespace
declaration or a class declaration.}
be
\addtoindexx{low PC attribute!and abstract instance}
omitted;
+\addtoindex{segment attribute!and abstract instance}
however,
\addtoindexx{return address attribute!and abstract instance}
this
a data type with a non\dash decimal and non\dash binary scale factor,
the fixed binary type entry has a
\livelink{chap:DWATsmall}{DW\-\_AT\-\_small} attribute which
+\addtoindexx{small attribute}
references a
\livelink{chap:DWTAGconstant}{DW\-\_TAG\-\_constant} entry. The scale factor value
is interpreted in accordance with the value defined by the
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
+The typedef entry may also contain a
+\livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute whose
value is a reference to the type named by the typedef. If
the debugging information entry for a typedef represents
a declaration of the type that is not also a definition,
If the amount of storage allocated to hold each element of an
object of the given array type is different from the amount
+\addtoindexx{stride attribute|see{bit stride attribute or byte stride attribute}}
of storage that is normally allocated to hold an individual
\hypertarget{chap:DWATbitstridearrayelementstrideofarraytype}
object of the
Each array dimension is described by a debugging information
-entry with either the tag \livelink{chap:DWTAGsubrangetype}{DW\-\_TAG\-\_subrange\-\_type} or the
+entry with either the
+\addtoindexx{subrange type entry!as array dimension}
+tag \livelink{chap:DWTAGsubrangetype}{DW\-\_TAG\-\_subrange\-\_type} or the
\addtoindexx{enumeration type entry!as array dimension}
tag
\livelink{chap:DWTAGenumerationtype}{DW\-\_TAG\-\_enumeration\-\_type}. These entries are
\addtoindex{C++}, and
\addtoindex{Pascal}, among others, allow the
programmer to define types that are collections of related
-components. In \addtoindex{C} and \addtoindex{C++}, these collections are called
-“structures.” In \addtoindex{Pascal}, they are called “records.”
+\addtoindexx{structure type entry}
+components.
+In \addtoindex{C} and \addtoindex{C++}, these collections are called
+“structures.”
+In \addtoindex{Pascal}, they are called “records.”
The components may be of different types. The components are
called “members” in \addtoindex{C} and
\addtoindex{C++}, and “fields” in \addtoindex{Pascal}.}
Structure, union, and class types are represented by debugging
-information entries with
-the tags \livetarg{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type},
+\addtoindexx{structure type entry}
+information entries
+\addtoindexx{union type entry}
+with
+\addtoindexx{class type entry}
+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,
If a structure, union or class entry represents the definition
of a structure, class or union member corresponding to a prior
incomplete structure, class or union, the entry may have a
-\livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} attribute whose value is a reference to
+\livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} attribute
+\addtoindexx{specification attribute}
+whose value is a reference to
the debugging information entry representing that incomplete
declaration.
Structure, union and class entries containing the
-\livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} attribute do not need to duplicate
+\livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} attribute
+\addtoindexx{specification attribute}
+do not need to duplicate
information provided by the declaration entry referenced by the
specification attribute. In particular, such entries do not
need to contain an attribute for the name of the structure,
If the definition for a given member of the structure, union
or class does not appear within the body of the declaration,
that member also has a debugging information entry describing
-its definition. That latter entry has a \livelink{chap:DWATspecification}{DW\-\_AT\-\_specification}
-attribute referencing the debugging information entry
+its definition. That latter entry has a
+\livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} attribute
+\addtoindexx{specification attribute}
+referencing the debugging information entry
owned by the body of the structure, union or class entry and
representing a non\dash defining declaration of the data, function
or type member. The referenced entry will not have information
\textit{The \addtoindex{Java} language defines ``interface'' types.
An interface
+\addtoindex{interface type entry}
in \addtoindex{Java} is similar to a \addtoindex{C++} or
\addtoindex{Java} class with only abstract
methods and constant data members.}
A member function is represented by a
\addtoindexx{member function entry}
-debugging information entry with the
+debugging information entry
+with the
+\addtoindexx{subprogram entry!as member function}
tag \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}.
The member function entry
may contain the same attributes and follows the same rules
If
\hypertarget{chap:DWATobjectpointerobjectthisselfpointerofmemberfunction}
the member function entry describes a non\dash static member
-function, then that entry has
+function, then that entry
+\addtoindexx{self pointer attribute|see{object pointer attribute}}
+has
\addtoindexx{object pointer attribute}
a \livelink{chap:DWATobjectpointer}{DW\-\_AT\-\_object\-\_pointer}
attribute
If a subroutine entry represents the defining declaration
of a member function and that definition appears outside of
the body of the enclosing class declaration, the subroutine
-entry has a \livelink{chap:DWATspecification}{DW\-\_AT\-\_specification}
-attribute, whose value is
+entry has a
+\livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} attribute,
+\addtoindexx{specification attribute}
+whose value is
a reference to the debugging information entry representing
the declaration of this function member. The referenced entry
will be a child of some class (or structure) type entry.
-Subroutine entries containing the \livelink{chap:DWATspecification}{DW\-\_AT\-\_specification}
-attribute do not need to duplicate information provided
+Subroutine entries containing the
+\livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} attribute
+\addtoindexx{specification attribute}
+do not need to duplicate information provided
by the declaration entry referenced by the specification
attribute. In particular, such entries do not need to contain
attributes for the name or return type of the function member
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
+template type parameter entry also has a
+\livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute
describing the actual type by which the formal is replaced
for this instantiation.
A subroutine type is represented by a debugging information
entry with the
+\addtoindexx{subroutine type entry}
tag \livetarg{chap:DWTAGsubroutinetype}{DW\-\_TAG\-\_subroutine\-\_type}.
If a name has
been given to the subroutine type in the source program,
A ``string'' is a sequence of characters that have specific
+\addtoindexx{string type entry}
semantics and operations that separate them from arrays of
characters.
\addtoindex{Fortran} is one of the languages that has a string
\hypertarget{chap:DWATstringlengthstringlengthofstringtype}
string type entry may have a
\livelink{chap:DWATstringlength}{DW\-\_AT\-\_string\-\_length} attribute
-whose value is a
+whose
+\addtoindexx{string length attribute}
+value is a
\addtoindex{location description} yielding the location
where the length of the string is stored in the program. The
string type entry may also have a \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} attribute
is the size of the data to be retrieved from the location
referenced by the string length attribute. If no (byte or bit)
size attribute is present, the size of the data to be retrieved
-is the same as the size of an address on the target machine.
+is the same as the
+\addtoindex{size of an address} on the target machine.
If no string length attribute is present, the string type
entry may have a \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} attribute or
A set is represented by a debugging information entry with
the tag \livetarg{chap:DWTAGsettype}{DW\-\_TAG\-\_set\-\_type}.
+\addtoindexx{set type entry}
If a name has been given to the
set type, then the set type entry has
a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute
\textit{Several languages support the concept of a ``subrange''
type object. These objects can represent a subset of the
values that an object of the basis type for the subrange can
-represent. Subrange type entries may also be used to represent
+represent.
+Subrange type entries may also be used to represent
the bounds of array dimensions.}
A subrange type is represented by a debugging information
entry with the
+\addtoindexx{subrange type entry}
tag \livetarg{chap:DWTAGsubrangetype}{DW\-\_TAG\-\_subrange\-\_type}.
If a name has been
given to the subrange type, then the subrange type entry
object of the given subrange type is different from the amount
of storage that is normally allocated to hold an individual
object of the indicated element type, then the subrange
-type entry has a \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} attribute or
+type entry has a
+\livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} attribute or
\livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size}
attribute, whose value
(see Section \refersec{chap:staticanddynamicvaluesofattributes})
DWARF Git Projects / dwarf-doc.git / commitdiff