Complete processing of review comments to date and do index improvements.
authorRon Brender <ron.brender@gmail.com>
Fri, 22 Aug 2014 14:12:57 +0000 (10:12 -0400)
committerRon Brender <ron.brender@gmail.com>
Fri, 22 Aug 2014 14:12:57 +0000 (10:12 -0400)
Signed-off-by: Ron Brender <ron.brender@gmail.com>
14 files changed:
dwarf5/latexdoc/changesummary.tex
dwarf5/latexdoc/compression.tex
dwarf5/latexdoc/datarepresentation.tex
dwarf5/latexdoc/debugsectionrelationships.tex
dwarf5/latexdoc/dwarf5.tex
dwarf5/latexdoc/dwarfnamecmds.tex
dwarf5/latexdoc/examples.tex
dwarf5/latexdoc/generaldescription.tex
dwarf5/latexdoc/introduction.tex
dwarf5/latexdoc/otherdebugginginformation.tex
dwarf5/latexdoc/programscope.tex
dwarf5/latexdoc/sectionversionnumbers.tex
dwarf5/latexdoc/splitobjects.tex
dwarf5/latexdoc/typeentries.tex

index 75dd816..5a06287 100644 (file)
@@ -15,6 +15,7 @@ This change summary is included only in draft versions of this document.
 \begin{longtable}{ll}
 \textbf{Date}  & \textbf{Issue Incorporated or Other Change}   \\ \hline       \\
 \endhead
+8/22/2014       & Miscellaneous editorial corrections, indexing improvements \\
 7/22/2014       & Add items in Section 1.4, Changes from Version 4 to Version 5 \\
 7/21/2014       & Enable section numbers on pdf bookmarks \\
 7/20/2014       & 140425.1 (typed stack), 140707.1 (Dylan language), review comments \\ 
index 7a07e7d..ac2da54 100644 (file)
@@ -451,7 +451,7 @@ the underlying object language is not (and varies from system to system).
 \subsubsection{C++ Example}
 
 The \addtoindex{C++} source 
-\addtoindexx{DWARF duplicate elimination!C++ example}
+\addtoindexx{DWARF duplicate elimination!examples}
 in 
 Figure \refersec{fig:duplicateeliminationexample1csource}
 is used to illustrate the DWARF
@@ -554,7 +554,7 @@ is not needed for the same reason.
 
 
 For a \addtoindex{Fortran}
-\addtoindexx{DWARF duplicate elimination!Fortran example}
+\addtoindexx{DWARF duplicate elimination!examples}
 example, consider 
 Figure \refersec{fig:duplicateeliminationexample2fortransource}.
 
@@ -726,7 +726,7 @@ visible as global entities.
 \subsubsection{C++ Example}
 
 The \addtoindex{C++} example 
-\addtoindexx{DWARF duplicate elimination!C++ example}
+\addtoindexx{DWARF duplicate elimination!examples}
 in this Section might appear to be equally
 valid as a \addtoindex{C} example. However, it is prudent to include
 a \DWTAGimportedunit{}
index b9cda16..f276437 100644 (file)
@@ -104,10 +104,10 @@ not appear in DWARF debugging information.
 \label{datarep:initiallengthvalues}
 \addtoindexx{reserved values!initial length}
 
-An \livetarg{datarep:initiallengthvalues}{initial length field} is one of the length fields that occur
-at the beginning 
-of those DWARF sections that 
-have a header
+An \livetarg{datarep:initiallengthvalues}{initial length} field 
+\addtoindex{initial length field|see{initial length}}
+is one of the length fields that occur at the beginning 
+of those DWARF sections that have a header
 (\dotdebugaranges{}, 
 \dotdebuginfo{}, 
 \dotdebugline{},
@@ -117,9 +117,9 @@ that occurs at the beginning of the CIE and FDE structures
 in the \dotdebugframe{} section.
 
 \needlines{4}
-In an \addtoindex{initial length field}, the values \wfffffffzero through
+In an \addtoindex{initial length} field, the values \wfffffffzero through
 \wffffffff are reserved by DWARF to indicate some form of
-extension relative to \addtoindex{DWARF Version 2}; such values must not
+extension relative to \DWARFVersionII; such values must not
 be interpreted as a length field. The use of one such value,
 \xffffffff, is defined below 
 (see Section \refersec{datarep:32bitand64bitdwarfformats}); 
@@ -132,6 +132,82 @@ the other values is reserved for possible future extensions.
 \label{datarep:executableobjectsandsharedobjects}
 
 \subsection{Relocatable Objects}
+\label{data:relocatableobjects}
+A DWARF producer (for example, a compiler) typically generates its
+debugging information as part of a relocatable object file.
+Relocatable object files are then combined by a linker to form an
+executable file. During the linking process, the linker resolves
+(binds) symbolic references between the various object files, and
+relocates the contents of each object file into a combined virtual
+address space.
+
+The DWARF debugging information is placed in several sections (see
+Appendix \refersec{app:debugsectionrelationshipsinformative}), and 
+requires an object file format capable of
+representing these separate sections. There are symbolic references
+between these sections, and also between the debugging information
+sections and the other sections that contain the text and data of the
+program itself. Many of these references require relocation, and the
+producer must emit the relocation information appropriate to the
+object file format and the target processor architecture. These
+references include the following:
+
+\begin{itemize}
+\item The compilation unit header (see Section 
+\refersec{datarep:unitheaders}) in the \dotdebuginfo{}
+section contains a reference to the \dotdebugabbrev{} table. This
+reference requires a relocation so that after linking, it refers to
+that contribution to the combined \dotdebugabbrev{} section in the
+executable file.
+
+\item Debugging information entries may have attributes with the form
+\DWFORMaddr{} (see Section \refersec{datarep:attributeencodings}). 
+These attributes represent locations
+within the virtual address space of the program, and require
+relocation.
+
+\item Debugging information entries may have attributes with the form
+\DWFORMsecoffset{} (see Section \refersec{datarep:attributeencodings}). 
+These attributes refer to
+debugging information in other debugging information sections within
+the object file, and must be relocated during the linking process.
+Exception: attributes whose values are relative to a base offset given
+by \DWATrangesbase{} do not need relocation.
+
+\item Debugging information entries may have attributes with the form
+\DWFORMrefone, \DWFORMreftwo, \DWFORMreffour, \DWFORMrefeight, or
+\DWFORMrefudata{} (see Section \refersec{datarep:attributeencodings}). 
+These attributes refer to other
+debugging information entries within the same compilation unit, and
+are relative to the beginning of the current compilation unit. These
+values do not need relocation.
+
+\item Debugging information entries may have attributes with the form
+\DWFORMrefaddr{} (see Section \refersec{datarep:attributeencodings}). 
+These attributes refer to
+debugging information entries that may be outside the current
+compilation unit. These values require both symbolic binding and
+relocation.
+
+\item Debugging information entries may have attributes with the form
+\DWFORMstrp{} (see Section \refersec{datarep:attributeencodings}). 
+These attributes refer to strings in
+the \dotdebugstr{} section. These values require relocation.
+
+\item Entries in the \dotdebugloc{}, \dotdebugranges{}, and \dotdebugaranges{}
+sections contain references to locations within the virtual address
+space of the program, and require relocation.
+
+\item In the \dotdebugline{} section, the operand of the \DWLNEsetaddress{}
+opcode is a reference to a location within the virtual address space
+of the program, and requires relocation.
+
+ The \dotdebugstroffsets{} section contains a list of string offsets,
+each of which is an offset of a string in the \dotdebugstr{} section. Each
+of these offsets requires relocation. Depending on the implementation,
+these relocations may be implicit (i.e., the producer may not need to
+emit any explicit relocation information for these offsets).
+\end{itemize}
 
 \subsection{Split DWARF Objects}
 \label{datarep:splitdwarfobjects}
@@ -249,12 +325,12 @@ produced during the compilation of an application.}
 
 \textit{The package file is typically placed in the same directory as the
 application, and is given the same name with a \doublequote{\texttt{.dwp}}
-extension.\addtoindexx{\texttt{.dap} file extension}}
+extension.\addtoindexx{\texttt{.dwp} file extension}}
 
 A DWARF package file is itself an object file, using the
 \addtoindexx{package files}
 \addtoindexx{DWARF package files}
-same object file format, byte order, and size as the
+same object file format (including byte order) as the
 corresponding application binary. It consists only of a file
 header, section table, a number of DWARF debug information
 sections, and two index sections.
@@ -463,13 +539,12 @@ detailed in the following:
 \begin{enumerate}[1. ]
 
 \item  In the 32\dash bit DWARF format, an 
-\addtoindex{initial length field}
-(see 
-\addtoindexx{initial length field!encoding}
+\addtoindex{initial length} field (see 
+\addtoindexx{initial length!encoding}
 Section \ref{datarep:initiallengthvalues} on page \pageref{datarep:initiallengthvalues})
 is an unsigned 32\dash bit integer (which
 must be less than \xfffffffzero); in the 64\dash bit DWARF format,
-an \addtoindex{initial length field} is 96 bits in size,
+an \addtoindex{initial length} field is 96 bits in size,
 and has two parts:
 \begin{itemize}
 \item The first 32\dash bits have the value \xffffffff.
@@ -487,10 +562,8 @@ format and to adapt its processing accordingly.}
 \addtoindexx{section length!use in headers}
 fields that occur
 \addtoindexx{section offset!use in headers}
-in the headers of DWARF sections (other 
-\addtoindexx{initial length field}
-than 
-\addtoindex{initial length}
+in the headers of DWARF sections (other than initial length
+\addtoindexx{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 
@@ -504,16 +577,16 @@ unsigned integer values.
 \begin{center}
 \begin{tabular}{lll}
 Section &Name & Role  \\ \hline
-\dotdebugaranges{} & \addtoindex{debug\_info\_offset} & offset in \dotdebuginfo{} \\
-\dotdebugframe{}/CIE & \addtoindex{CIE\_id} & CIE distinguished value \\
-\dotdebugframe{}/FDE & \addtoindex{CIE\_pointer} & offset in \dotdebugframe{} \\
-\dotdebuginfo{} & \addtoindex{debug\_abbrev\_offset} & offset in \dotdebugabbrev{} \\
-\dotdebugline{} & \addtoindex{header\_length} & length of header itself \\
-\dotdebugpubnames{} & \addtoindex{debug\_info\_offset} & offset in \dotdebuginfo{} \\
-                & \addtoindex{debug\_info\_length} & length of \dotdebuginfo{} \\
+\dotdebugaranges{} & \addttindex{debug\_info\_offset} & offset in \dotdebuginfo{} \\
+\dotdebugframe{}/CIE & \addttindex{CIE\_id} & CIE distinguished value \\
+\dotdebugframe{}/FDE & \addttindex{CIE\_pointer} & offset in \dotdebugframe{} \\
+\dotdebuginfo{} & \addttindex{debug\_abbrev\_offset} & offset in \dotdebugabbrev{} \\
+\dotdebugline{} & \addttindex{header\_length} & length of header itself \\
+\dotdebugpubnames{} & \addttindex{debug\_info\_offset} & offset in \dotdebuginfo{} \\
+                & \addttindex{debug\_info\_length} & length of \dotdebuginfo{} \\
                 &                   & contribution \\
-\dotdebugpubtypes{} & \addtoindex{debug\_info\_offset} & offset in \dotdebuginfo{} \\
-                & \addtoindex{debug\_info\_length} & length of \dotdebuginfo{} \\
+\dotdebugpubtypes{} & \addttindex{debug\_info\_offset} & offset in \dotdebuginfo{} \\
+                & \addttindex{debug\_info\_length} & length of \dotdebuginfo{} \\
                 &                   & contribution \\
 \end{tabular}
 \end{center}
@@ -633,7 +706,7 @@ units may share the same table.
 
 \subsection{Unit Headers}
 \label{datarep:unitheaders}
-Unit headers contain a field, \texttt{unit\_type}, whose value indicates the kind of
+Unit headers contain a field, \addttindex{unit\_type}, whose value indicates the kind of
 compilation unit that follows. The encodings for the unit type 
 enumeration are shown in Table \refersec{tab:unitheaderunitkindencodings}.
 
@@ -643,7 +716,7 @@ enumeration are shown in Table \refersec{tab:unitheaderunitkindencodings}.
 \begin{longtable}{l|c}
   \caption{Unit header unit type encodings}
   \label{tab:unitheaderunitkindencodings}
-  \addtoindexx{Unit header unit type encodings} \\
+  \addtoindexx{unit header unit type encodings} \\
   \hline \bfseries Unit header unit type encodings&\bfseries Value \\ \hline
 \endfirsthead
   \bfseries Unit header unit type encodings&\bfseries Value \\ \hline
@@ -712,7 +785,6 @@ an address on the target architecture. If the system uses
 segmented addressing, this value represents the size of the
 offset portion of an address.
 
-
 \end{enumerate}
 
 \subsubsection{Type Unit Header}
@@ -766,7 +838,7 @@ in the \sixtyfourbitdwarfformat, this is an 8\dash byte unsigned length
 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
 
 \needlines{4}
-\item \texttt{address\_size} (ubyte) \\
+\item \texttt{address\_size} (addtoindex{ubyte}) \\
 A 1\dash byte unsigned integer representing the size 
 \addtoindexx{size of an address}
 in bytes of
@@ -1432,232 +1504,232 @@ Table \refersec{tab:attributeformencodings}.
   \hline \ddag\ \textit{New in DWARF Version 5}
 \endlastfoot
 \DWATsibling&0x01&\livelink{chap:classreference}{reference} 
-            \addtoindexx{sibling attribute!encoding} \\
+            \addtoindexx{sibling attribute} \\
 \DWATlocation&0x02&\livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classloclistptr}{loclistptr}
-            \addtoindexx{location attribute!encoding}   \\
+            \addtoindexx{location attribute}   \\
 \DWATname&0x03&\livelink{chap:classstring}{string} 
-            \addtoindexx{name attribute!encoding} \\
+            \addtoindexx{name attribute} \\
 \DWATordering&0x09&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{ordering attribute!encoding}  \\
+            \addtoindexx{ordering attribute}  \\
 \DWATbytesize&0x0b&\livelink{chap:classconstant}{constant}, 
         \livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classreference}{reference}
-            \addtoindexx{byte size attribute!encoding} \\
+            \addtoindexx{byte size attribute} \\
 \DWATbitoffset&0x0c&\livelink{chap:classconstant}{constant}, 
         \livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classreference}{reference}
-            \addtoindexx{bit offset attribute!encoding}  \\
+            \addtoindexx{bit offset attribute (Version 3)}  \\
 \DWATbitsize&0x0d&\livelink{chap:classconstant}{constant}, 
         \livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classreference}{reference}   
-            \addtoindexx{bit size attribute!encoding} \\
+            \addtoindexx{bit size attribute} \\
 \DWATstmtlist&0x10&\livelink{chap:classlineptr}{lineptr} 
-            \addtoindexx{statement list attribute!encoding} \\
+            \addtoindexx{statement list attribute} \\
 \DWATlowpc&0x11&\livelink{chap:classaddress}{address} 
-            \addtoindexx{low PC attribute!encoding}  \\
+            \addtoindexx{low PC attribute}  \\
 \DWAThighpc&0x12&\livelink{chap:classaddress}{address}, 
         \livelink{chap:classconstant}{constant}
-            \addtoindexx{high PC attribute!encoding}  \\
+            \addtoindexx{high PC attribute}  \\
 \DWATlanguage&0x13&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{language attribute!encoding}  \\
+            \addtoindexx{language attribute}  \\
 \DWATdiscr&0x15&\livelink{chap:classreference}{reference} 
-            \addtoindexx{discriminant attribute!encoding}  \\
+            \addtoindexx{discriminant attribute}  \\
 \DWATdiscrvalue&0x16&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{discriminant value attribute!encoding}  \\
+            \addtoindexx{discriminant value attribute}  \\
 \DWATvisibility&0x17&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{visibility attribute!encoding} \\
+            \addtoindexx{visibility attribute} \\
 \DWATimport&0x18&\livelink{chap:classreference}{reference} 
-            \addtoindexx{import attribute!encoding}  \\
+            \addtoindexx{import attribute}  \\
 \DWATstringlength&0x19&\livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classloclistptr}{loclistptr}
-            \addtoindexx{string length attribute!encoding}  \\
+            \addtoindexx{string length attribute}  \\
 \DWATcommonreference&0x1a&\livelink{chap:classreference}{reference} 
-            \addtoindexx{common reference attribute!encoding}  \\
+            \addtoindexx{common reference attribute}  \\
 \DWATcompdir&0x1b&\livelink{chap:classstring}{string} 
-            \addtoindexx{compilation directory attribute!encoding}  \\
+            \addtoindexx{compilation directory attribute}  \\
 \DWATconstvalue&0x1c&\livelink{chap:classblock}{block}, 
         \livelink{chap:classconstant}{constant}, 
         \livelink{chap:classstring}{string}
-            \addtoindexx{constant value attribute!encoding} \\
+            \addtoindexx{constant value attribute} \\
 \DWATcontainingtype&0x1d&\livelink{chap:classreference}{reference} 
-            \addtoindexx{containing type attribute!encoding} \\
+            \addtoindexx{containing type attribute} \\
 \DWATdefaultvalue&0x1e&\livelink{chap:classconstant}{constant}, 
         \livelink{chap:classreference}{reference}, 
         \livelink{chap:classflag}{flag}
-            \addtoindexx{default value attribute!encoding} \\
+            \addtoindexx{default value attribute} \\
 \DWATinline&0x20&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{inline attribute!encoding}  \\
+            \addtoindexx{inline attribute}  \\
 \DWATisoptional&0x21&\livelink{chap:classflag}{flag} 
-            \addtoindexx{is optional attribute!encoding} \\
+            \addtoindexx{is optional attribute} \\
 \DWATlowerbound&0x22&\livelink{chap:classconstant}{constant}, 
         \livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classreference}{reference}
-            \addtoindexx{lower bound attribute!encoding}  \\
+            \addtoindexx{lower bound attribute}  \\
 \DWATproducer&0x25&\livelink{chap:classstring}{string}
-            \addtoindexx{producer attribute!encoding}  \\
+            \addtoindexx{producer attribute}  \\
 \DWATprototyped&0x27&\livelink{chap:classflag}{flag}
-            \addtoindexx{prototyped attribute!encoding}  \\
+            \addtoindexx{prototyped attribute}  \\
 \DWATreturnaddr&0x2a&\livelink{chap:classexprloc}{exprloc},
         \livelink{chap:classloclistptr}{loclistptr}
-            \addtoindexx{return address attribute!encoding}  \\
+            \addtoindexx{return address attribute}  \\
 \DWATstartscope&0x2c&\livelink{chap:classconstant}{constant}, 
         \livelink{chap:classrangelistptr}{rangelistptr}
-            \addtoindexx{start scope attribute!encoding}  \\
+            \addtoindexx{start scope attribute}  \\
 \DWATbitstride&0x2e&\livelink{chap:classconstant}{constant},
         \livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classreference}{reference}
-            \addtoindexx{bit stride attribute!encoding}  \\
+            \addtoindexx{bit stride attribute}  \\
 \DWATupperbound&0x2f&\livelink{chap:classconstant}{constant},
         \livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classreference}{reference}
-            \addtoindexx{upper bound attribute!encoding}  \\
+            \addtoindexx{upper bound attribute}  \\
 \DWATabstractorigin&0x31&\livelink{chap:classreference}{reference} 
-            \addtoindexx{abstract origin attribute!encoding}  \\
+            \addtoindexx{abstract origin attribute}  \\
 \DWATaccessibility&0x32&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{accessibility attribute!encoding}  \\
+            \addtoindexx{accessibility attribute}  \\
 \DWATaddressclass&0x33&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{address class attribute!encoding}  \\
+            \addtoindexx{address class attribute}  \\
 \DWATartificial&0x34&\livelink{chap:classflag}{flag} 
-            \addtoindexx{artificial attribute!encoding}  \\
+            \addtoindexx{artificial attribute}  \\
 \DWATbasetypes&0x35&\livelink{chap:classreference}{reference} 
-            \addtoindexx{base types attribute!encoding}  \\
+            \addtoindexx{base types attribute}  \\
 \DWATcallingconvention&0x36&\livelink{chap:classconstant}{constant} 
-        \addtoindexx{calling convention attribute!encoding} \\
+        \addtoindexx{calling convention attribute} \\
 \DWATcount&0x37&\livelink{chap:classconstant}{constant}, 
         \livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classreference}{reference} 
-            \addtoindexx{count attribute!encoding}  \\
+            \addtoindexx{count attribute}  \\
 \DWATdatamemberlocation&0x38&\livelink{chap:classconstant}{constant}, 
         \livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classloclistptr}{loclistptr} 
-            \addtoindexx{data member attribute!encoding}  \\
+            \addtoindexx{data member attribute}  \\
 \DWATdeclcolumn&0x39&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{declaration column attribute!encoding}  \\
+            \addtoindexx{declaration column attribute}  \\
 \DWATdeclfile&0x3a&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{declaration file attribute!encoding}  \\
+            \addtoindexx{declaration file attribute}  \\
 \DWATdeclline&0x3b&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{declaration line attribute!encoding}  \\
+            \addtoindexx{declaration line attribute}  \\
 \DWATdeclaration&0x3c&\livelink{chap:classflag}{flag} 
-            \addtoindexx{declaration attribute!encoding}  \\
+            \addtoindexx{declaration attribute}  \\
 \DWATdiscrlist&0x3d&\livelink{chap:classblock}{block} 
-            \addtoindexx{discriminant list attribute!encoding}  \\
+            \addtoindexx{discriminant list attribute}  \\
 \DWATencoding&0x3e&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{encoding attribute!encoding}  \\
+            \addtoindexx{encoding attribute}  \\
 \DWATexternal&\xiiif&\livelink{chap:classflag}{flag} 
-            \addtoindexx{external attribute!encoding}  \\
+            \addtoindexx{external attribute}  \\
 \DWATframebase&0x40&\livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classloclistptr}{loclistptr} 
-            \addtoindexx{frame base attribute!encoding}  \\
+            \addtoindexx{frame base attribute}  \\
 \DWATfriend&0x41&\livelink{chap:classreference}{reference} 
-            \addtoindexx{friend attribute!encoding}  \\
+            \addtoindexx{friend attribute}  \\
 \DWATidentifiercase&0x42&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{identifier case attribute!encoding}  \\
+            \addtoindexx{identifier case attribute}  \\
 \DWATmacroinfo\footnote{\raggedright Not used in \DWARFVersionV. 
                         Reserved for compatibility and coexistence
                         with prior DWARF versions.}
             &0x43&\livelink{chap:classmacptr}{macptr} 
             \addtoindexx{macro information attribute (legacy)!encoding}  \\
 \DWATnamelistitem&0x44&\livelink{chap:classreference}{reference} 
-            \addtoindexx{name list item attribute!encoding}  \\
+            \addtoindexx{name list item attribute}  \\
 \DWATpriority&0x45&\livelink{chap:classreference}{reference} 
-            \addtoindexx{priority attribute!encoding}  \\
+            \addtoindexx{priority attribute}  \\
 \DWATsegment&0x46&\livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classloclistptr}{loclistptr} 
-            \addtoindexx{segment attribute!encoding}  \\
+            \addtoindexx{segment attribute}  \\
 \DWATspecification&0x47&\livelink{chap:classreference}{reference} 
-        \addtoindexx{specification attribute!encoding}  \\
+        \addtoindexx{specification attribute}  \\
 \DWATstaticlink&0x48&\livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classloclistptr}{loclistptr} 
-            \addtoindexx{static link attribute!encoding}  \\
+            \addtoindexx{static link attribute}  \\
 \DWATtype&0x49&\livelink{chap:classreference}{reference} 
-            \addtoindexx{type attribute!encoding}  \\
+            \addtoindexx{type attribute}  \\
 \DWATuselocation&0x4a&\livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classloclistptr}{loclistptr} 
-            \addtoindexx{location list attribute!encoding}  \\
+            \addtoindexx{location list attribute}  \\
 \DWATvariableparameter&0x4b&\livelink{chap:classflag}{flag} 
-            \addtoindexx{variable parameter attribute!encoding}  \\
+            \addtoindexx{variable parameter attribute}  \\
 \DWATvirtuality&0x4c&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{virtuality attribute!encoding}  \\
+            \addtoindexx{virtuality attribute}  \\
 \DWATvtableelemlocation&0x4d&\livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classloclistptr}{loclistptr} 
-            \addtoindexx{vtable element location attribute!encoding}  \\
+            \addtoindexx{vtable element location attribute}  \\
 \DWATallocated&0x4e&\livelink{chap:classconstant}{constant}, 
         \livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classreference}{reference} 
-            \addtoindexx{allocated attribute!encoding}  \\
+            \addtoindexx{allocated attribute}  \\
 \DWATassociated&0x4f&\livelink{chap:classconstant}{constant}, 
         \livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classreference}{reference} 
-            \addtoindexx{associated attribute!encoding}  \\
+            \addtoindexx{associated attribute}  \\
 \DWATdatalocation&0x50&\livelink{chap:classexprloc}{exprloc} 
-        \addtoindexx{data location attribute!encoding}  \\
+        \addtoindexx{data location attribute}  \\
 \DWATbytestride&0x51&\livelink{chap:classconstant}{constant}, 
         \livelink{chap:classexprloc}{exprloc}, 
         \livelink{chap:classreference}{reference} 
-            \addtoindexx{byte stride attribute!encoding}  \\
+            \addtoindexx{byte stride attribute}  \\
 \DWATentrypc&0x52&\livelink{chap:classaddress}{address}, 
         \livelink{chap:classconstant}{constant} 
-            \addtoindexx{entry pc attribute!encoding}  \\
+            \addtoindexx{entry pc attribute}  \\
 \DWATuseUTFeight&0x53&\livelink{chap:classflag}{flag} 
-            \addtoindexx{use UTF8 attribute!encoding}\addtoindexx{UTF-8}  \\
+            \addtoindexx{use UTF8 attribute}\addtoindexx{UTF-8}  \\
 \DWATextension&0x54&\livelink{chap:classreference}{reference} 
-            \addtoindexx{extension attribute!encoding}  \\
+            \addtoindexx{extension attribute}  \\
 \DWATranges&0x55&\livelink{chap:classrangelistptr}{rangelistptr} 
-            \addtoindexx{ranges attribute!encoding}  \\
+            \addtoindexx{ranges attribute}  \\
 \DWATtrampoline&0x56&\livelink{chap:classaddress}{address}, 
         \livelink{chap:classflag}{flag}, 
         \livelink{chap:classreference}{reference}, 
         \livelink{chap:classstring}{string} 
-            \addtoindexx{trampoline attribute!encoding}  \\
+            \addtoindexx{trampoline attribute}  \\
 \DWATcallcolumn&0x57&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{call column attribute!encoding}  \\
+            \addtoindexx{call column attribute}  \\
 \DWATcallfile&0x58&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{call file attribute!encoding}  \\
+            \addtoindexx{call file attribute}  \\
 \DWATcallline&0x59&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{call line attribute!encoding}  \\
+            \addtoindexx{call line attribute}  \\
 \DWATdescription&0x5a&\livelink{chap:classstring}{string} 
-            \addtoindexx{description attribute!encoding}  \\
+            \addtoindexx{description attribute}  \\
 \DWATbinaryscale&0x5b&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{binary scale attribute!encoding}  \\
+            \addtoindexx{binary scale attribute}  \\
 \DWATdecimalscale&0x5c&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{decimal scale attribute!encoding}  \\
+            \addtoindexx{decimal scale attribute}  \\
 \DWATsmall{} &0x5d&\livelink{chap:classreference}{reference} 
-            \addtoindexx{small attribute!encoding}  \\
+            \addtoindexx{small attribute}  \\
 \DWATdecimalsign&0x5e&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{decimal scale attribute!encoding}  \\
+            \addtoindexx{decimal scale attribute}  \\
 \DWATdigitcount&0x5f&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{digit count attribute!encoding}  \\
+            \addtoindexx{digit count attribute}  \\
 \DWATpicturestring&0x60&\livelink{chap:classstring}{string} 
-            \addtoindexx{picture string attribute!encoding}  \\
+            \addtoindexx{picture string attribute}  \\
 \DWATmutable&0x61&\livelink{chap:classflag}{flag} 
-            \addtoindexx{mutable attribute!encoding}  \\
+            \addtoindexx{mutable attribute}  \\
 \DWATthreadsscaled&0x62&\livelink{chap:classflag}{flag} 
-            \addtoindexx{thread scaled attribute!encoding}  \\
+            \addtoindexx{thread scaled attribute}  \\
 \DWATexplicit&0x63&\livelink{chap:classflag}{flag} 
-            \addtoindexx{explicit attribute!encoding}  \\
+            \addtoindexx{explicit attribute}  \\
 \DWATobjectpointer&0x64&\livelink{chap:classreference}{reference} 
-            \addtoindexx{object pointer attribute!encoding}  \\
+            \addtoindexx{object pointer attribute}  \\
 \DWATendianity&0x65&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{endianity attribute!encoding}  \\
+            \addtoindexx{endianity attribute}  \\
 \DWATelemental&0x66&\livelink{chap:classflag}{flag} 
-            \addtoindexx{elemental attribute!encoding}  \\
+            \addtoindexx{elemental attribute}  \\
 \DWATpure&0x67&\livelink{chap:classflag}{flag} 
-            \addtoindexx{pure attribute!encoding}  \\
+            \addtoindexx{pure attribute}  \\
 \DWATrecursive&0x68&\livelink{chap:classflag}{flag} 
-            \addtoindexx{recursive attribute!encoding}  \\
+            \addtoindexx{recursive attribute}  \\
 \DWATsignature{} &0x69&\livelink{chap:classreference}{reference} 
-            \addtoindexx{signature attribute!encoding}  \\ 
+            \addtoindexx{signature attribute}  \\ 
 \DWATmainsubprogram{} &0x6a&\livelink{chap:classflag}{flag} 
-            \addtoindexx{main subprogram attribute!encoding}  \\
+            \addtoindexx{main subprogram attribute}  \\
 \DWATdatabitoffset{} &0x6b&\livelink{chap:classconstant}{constant} 
-            \addtoindexx{data bit offset attribute!encoding}  \\
+            \addtoindexx{data bit offset attribute}  \\
 \DWATconstexpr{} &0x6c&\livelink{chap:classflag}{flag} 
-            \addtoindexx{constant expression attribute!encoding}  \\
+            \addtoindexx{constant expression attribute}  \\
 \DWATenumclass{} &0x6d&\livelink{chap:classflag}{flag} 
-            \addtoindexx{enumeration class attribute!encoding}  \\
+            \addtoindexx{enumeration class attribute}  \\
 \DWATlinkagename{} &0x6e&\livelink{chap:classstring}{string} 
-            \addtoindexx{linkage name attribute!encoding}  \\
+            \addtoindexx{linkage name attribute}  \\
 \DWATstringlengthbitsize{}~\ddag&0x6f&
                \livelink{chap:classconstant}{constant}
             \addtoindexx{string length attribute!size of length}  \\
@@ -1667,7 +1739,7 @@ Table \refersec{tab:attributeformencodings}.
 \DWATrank~\ddag&0x71&
         \livelink{chap:classconstant}{constant},
         \livelink{chap:classexprloc}{exprloc}
-            \addtoindexx{rank attribute!encoding}  \\
+            \addtoindexx{rank attribute}  \\
 \DWATstroffsetsbase~\ddag&0x72&
                \livelinki{chap:classstring}{stroffsetsptr}{stroffsetsptr class}
             \addtoindexx{string offsets base!encoding} \\
@@ -1688,35 +1760,35 @@ Table \refersec{tab:attributeformencodings}.
 \DWATrvaluereference~\ddag &0x78&
         \livelink{chap:DWATrvaluereference}{flag} \\
 \DWATmacros~\ddag &0x79&\livelink{chap:classmacptr}{macptr} 
-        \addtoindexx{macro information attribute!encoding}  \\
+        \addtoindexx{macro information attribute}  \\
 \DWATcallallcalls~\ddag &0x7a&\CLASSflag
-        \addtoindexx{all calls summary attribute!encoding} \\
+        \addtoindexx{all calls summary attribute} \\
 \DWATcallallsourcecalls~\ddag &0x7b &\CLASSflag
-        \addtoindexx{all source calls summary attribute!encoding} \\
+        \addtoindexx{all source calls summary attribute} \\
 \DWATcallalltailcalls~\ddag &0x7c&\CLASSflag
-        \addtoindexx{all tail calls summary attribute!encoding} \\
+        \addtoindexx{all tail calls summary attribute} \\
 \DWATcalldatalocation~\ddag &0x7d &\CLASSexprloc
-        \addtoindexx{call data location attribute!encoding} \\
+        \addtoindexx{call data location attribute} \\
 \DWATcalldatavalue~\ddag &0x7e &\CLASSexprloc
-        \addtoindexx{call data value attribute!encoding} \\
+        \addtoindexx{call data value attribute} \\
 \DWATcallorigin~\ddag &0x7f &\CLASSexprloc
-        \addtoindexx{call origin attribute!encoding} \\
+        \addtoindexx{call origin attribute} \\
 \DWATcallparameter~\ddag &0x80 &\CLASSreference
-        \addtoindexx{call parameter attribute!encoding} \\
+        \addtoindexx{call parameter attribute} \\
 \DWATcallpc~\ddag &0x81 &\CLASSaddress
-        \addtoindexx{call pc attribute!encoding} \\
+        \addtoindexx{call pc attribute} \\
 \DWATcallreturnpc~\ddag &0x82 &\CLASSaddress
-        \addtoindexx{call return pc attribute!encoding} \\
+        \addtoindexx{call return pc attribute} \\
 \DWATcalltailcall~\ddag &0x83 &\CLASSflag
-        \addtoindexx{call tail call attribute!encoding} \\
+        \addtoindexx{call tail call attribute} \\
 \DWATcalltarget~\ddag &0x84 &\CLASSexprloc
-        \addtoindexx{call target attribute!encoding} \\
+        \addtoindexx{call target attribute} \\
 \DWATcalltargetclobbered~\ddag &0x85 &\CLASSexprloc
-        \addtoindexx{call target clobbered attribute!encoding} \\
+        \addtoindexx{call target clobbered attribute} \\
 \DWATcallvalue~\ddag &0x86 &\CLASSexprloc
-        \addtoindexx{call value attribute!encoding} \\
+        \addtoindexx{call value attribute} \\
 \DWATnoreturn~\ddag &0x87 &\CLASSflag 
-        \addtoindexx{noreturn attribute!encoding} \\
+        \addtoindexx{noreturn attribute} \\
 \DWATlouser&0x2000 & --- \addtoindexx{low user attribute encoding}  \\
 \DWAThiuser&\xiiifff& --- \addtoindexx{high user attribute encoding}  \\
 
@@ -1895,7 +1967,7 @@ gives algorithms for encoding and decoding these forms.}
 \label{datarep:dwarfexpressions}
 
 A 
-\addtoindexx{DWARF Expression!operator encoding}
+\addtoindexx{DWARF expression!operator encoding}
 DWARF expression is stored in a \nolink{block} of contiguous
 bytes. The bytes form a sequence of operations. Each operation
 is a 1\dash byte code that identifies that operation, followed by
@@ -2090,7 +2162,7 @@ Table \refersec{tab:locationlistentryencodingvalues}.
 The encodings of the 
 \hypertarget{chap:DWATencodingencodingofbasetype}{}
 constants used in 
-\addtoindexx{encoding attribute!encoding}
+\addtoindexx{encoding attribute}
 the 
 \DWATencoding{}
 attribute are given in 
@@ -2192,7 +2264,7 @@ Table \refersec{tab:endianityencodings}.
 The encodings of the constants used in the 
 \DWATaccessibility{}
 attribute 
-\addtoindexx{accessibility attribute!encoding}
+\addtoindexx{accessibility attribute}
 are given in 
 Table \refersec{tab:accessibilityencodings}.
 
@@ -2358,8 +2430,7 @@ defined language.
 \label{datarep:addressclassencodings}
 
 The value of the common 
-\addtoindexi{address}{address class!attribute encoding}
-class encoding 
+\addtoindex{address class} encoding 
 \DWADDRnone{} is 0.
 
 \needlines{7}
@@ -2422,7 +2493,7 @@ Table \refersec{tab:callingconventionencodings}.
 \label{datarep:inlinecodes}
 
 The encodings of the constants used in 
-\addtoindexx{inline attribute!encoding}
+\addtoindexx{inline attribute}
 the 
 \DWATinline{} attribute are given in 
 Table \refersec{tab:inlineencodings}.
@@ -2484,7 +2555,7 @@ Table \refersec{tab:orderingencodings}.
 \label{datarep:discriminantlists}
 
 The descriptors used in 
-\addtoindexx{discriminant list attribute!encoding}
+\addtoindexx{discriminant list attribute}
 the 
 \DWATdiscrlist{} attribute are 
 encoded as 1\dash byte constants. The
@@ -2543,7 +2614,7 @@ DWARF information for the name lookup table
 The value in this field is 2.
 
 \needlines{4}
-\item \addtoindex{debug\_info\_offset} (section offset) \\
+\item \addttindex{debug\_info\_offset} (section offset) \\
 A 
 \addtoindexx{section offset!in name lookup table set of entries}
 4\dash byte or 8\dash byte 
@@ -2554,7 +2625,7 @@ In the \thirtytwobitdwarfformat, this is a 4\dash byte unsigned offset;
 in the \sixtyfourbitdwarfformat, this is an 8\dash byte unsigned offsets
 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
 
-\item  \addtoindex{debug\_info\_length} (\livelink{datarep:sectionoffsetlength}{section length}) \\
+\item  \addttindex{debug\_info\_length} (\livelink{datarep:sectionoffsetlength}{section length}) \\
 \addtoindexx{section length!in .debug\_pubnames header}
 A 
 \addtoindexx{section length!in .debug\_pubtypes header}
@@ -2619,18 +2690,18 @@ this is a 4\dash byte unsigned offset; in the \sixtyfourbitdwarfformat,
 this is an 8\dash byte unsigned offset 
 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
 
-\item address\_size (ubyte) \\
+\item \texttt{address\_size} (\addtoindex{ubyte}) \\
 A 1\dash byte unsigned integer containing the size in bytes of an
-\addtoindexx{address\_size}
+\addttindexx{address\_size}
 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) \\
+\item \texttt{segment\_size} (\addtoindex{ubyte}) \\
 A 
-\addtoindexx{segment\_size}
+\addttindexx{segment\_size}
 1\dash byte unsigned integer containing the size in bytes of a
 segment selector on the target system.
 
@@ -2639,8 +2710,8 @@ segment selector on the target system.
 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 \addtoindex{segment\_size} field of the header; the
-address and length size are each given by the address\_size
+size is given by the \addttindex{segment\_size} field of the header; the
+address and length size are each given by the \addttindex{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
@@ -2649,7 +2720,7 @@ 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 \addtoindex{segment\_size} field in the header is zero,
+length. If the \addttindex{segment\_size} field in the header is zero,
 the segment selectors are omitted from all tuples, including
 the terminating tuple.
 
@@ -2965,9 +3036,9 @@ bytes of a segment selector on the target system.
 \end{enumerate}
 
 This header is followed by a series of segment/address pairs.
-The segment size is given by the \texttt{segment\_size} field of the
-header, and the address size is given by the \texttt{address\_size}
-field of the header. If the \texttt{segment\_size} field in the header
+The segment size is given by the \addttindex{segment\_size} field of the
+header, and the address size is given by the \addttindex{address\_size}
+field of the header. If the \addttindex{segment\_size} field in the header
 is zero, the entries consist only of an addresses.
 
 The \DWATaddrbase{} attribute points to the first entry
@@ -3012,9 +3083,9 @@ bytes of a segment selector on the target system.
 This header is followed by a series of range list entries as
 described in Section \refersec{chap:locationlists}.
 The segment size is given by the
-\texttt{segment\_size} field of the header, and the address size is
-given by the \texttt{address\_size} field of the header. If the
-\texttt{segment\_size} field in the header is zero, the segment
+\addttindex{segment\_size} field of the header, and the address size is
+given by the \addttindex{address\_size} field of the header. If the
+\addttindex{segment\_size} field in the header is zero, the segment
 selector is omitted from the range list entries.
 
 The \DWATrangesbase{} attribute points to the first entry
@@ -3060,9 +3131,9 @@ bytes of a segment selector on the target system.
 This header is followed by a series of location list entries as
 described in Section \refersec{chap:locationlists}.
 The segment size is given by the
-\texttt{segment\_size} field of the header, and the address size is
+\addttindex{segment\_size} field of the header, and the address size is
 given by the \texttt{address\_size} field of the header. If the
-\texttt{segment\_size} field in the header is zero, the segment
+\addttindex{segment\_size} field in the header is zero, the segment
 selector is omitted from the range list entries.
 
 The entries are referenced by a byte offset relative to the first
index ffbb735..f6c7ac5 100644 (file)
@@ -180,7 +180,8 @@ section of the corresponding string.
 %e
 \item \dotdebugstroffsets{} to \dotdebugstroffsets \\
 The value of the \DWATstroffsetsbase{} attribute in a
-compilation, partial or type unit DIE is the offset in the
+\DWTAGcompileunit{}, \DWTAGtypeunit{} or \DWTAGpartialunit{} 
+DIE is the offset in the
 \dotdebugstroffsets{} section of the 
 \addtoindex{string offsets table}
 for that unit.
@@ -251,7 +252,7 @@ are offsets to the corresponding string text in the
 %m
 \item \dotdebugmacro{} to \dotdebugstroffsets \\
 The second operand of a 
-\DWMACROdefineindirect{} macroinfo
+\DWMACROdefineindirect{} or \DWMACROundefindirect{} macro information
 entry is an index into the string table in the 
 \dotdebugstr{} section.
 
@@ -261,7 +262,7 @@ entry is an index into the string table in the
 The second operand of 
 \DWMACROstartfile{} refers to a file entry in the 
 \dotdebugline{} section relative to the start 
-of that section given in the macroinfo header.
+of that section given in the macro information header.
 
 %o
 \item \dotdebugloc{} to \dotdebugaddr \\
@@ -274,14 +275,15 @@ section.
 %p
 \item \dotdebugmacro{} to \dotdebugstroffsets \\
 The second operand of a 
-\DWMACROdefineindirectx{} macroinfo entry is an index
+\DWMACROdefineindirectx{} or \DWMACROundefindirectx{} 
+macro information entry is an index
 into the string offset table in the 
 \dotdebugstroffsets{} section.
 
 %q
 \item \dotdebugmacro{} to \dotdebugmacro \\
 The second operand of a 
-\DWMACROtransparentinclude{} macroinfo
+\DWMACROtransparentinclude{} macro information
 entry is an offset into another part of the 
 \dotdebugmacro{} section to the header for the 
 sequence to be transparently included.
index c612987..2a32066 100644 (file)
@@ -3,7 +3,7 @@
 % If draft is in the document class list, pix are just suggested
 % by an outline, the pic does not appear as a picture.
 %
-\newcommand{\docdate}{July 22, 2014}
+\newcommand{\docdate}{August 22, 2014}
 %
 \usepackage{ifthen}
 \newboolean{isdraft}
index 4bdbb16..a328647 100644 (file)
 % Miscellaneous
 %
 \newcommand{\MDfive}{\livelink{def:MDfive}{MD5}}
-\newcommand{\COMDAT}{\addtoindex{COMDAT}}
\ No newline at end of file
+\newcommand{\COMDAT}{\addtoindex{COMDAT}}
+\newcommand{\autoreturntype}{\texttt{auto} return type\index{auto return type@\texttt{auto} return type}}
\ No newline at end of file
index ca2c072..73776e4 100644 (file)
@@ -1529,13 +1529,13 @@ Figure \refersec{fig:linenumberprogramexamplemachinecode}.
 
 Suppose the line number program header includes the following
 (header fields not needed 
-\addtoindexx{line\_base}
+\addttindexx{line\_base}
 below 
-\addtoindexx{line\_range}
+\addttindexx{line\_range}
 are 
-\addtoindexx{opcode\_base}
+\addttindexx{opcode\_base}
 not 
-\addtoindexx{minumum\_instruction\_length}
+\addttindexx{minimum\_instruction\_length}
 shown):
 \begin{alltt}
     version                       4
@@ -2822,7 +2822,7 @@ int main ()
 \end{figure}
 
 \begin{figure}[h]
-\addtoindexx{implicit pointer example \#1}
+\addtoindexx{implicit pointer example}
 \begin{dwflisting}
 \begin{alltt}
 1\$: \DWTAGstructuretype
@@ -2918,7 +2918,7 @@ int main ()
 \end{figure}
 
 \begin{figure}[h]
-\addtoindexx{implicit pointer example \#2}
+\addtoindexx{implicit pointer example}
 \begin{dwflisting}
 \begin{alltt}
 1\$: \DWTAGvariable
index 039eaf7..e6428b6 100644 (file)
@@ -220,12 +220,12 @@ The attributes are listed in Table \referfol{tab:attributenames}.
 \DWATcalldatalocationTARG{}
 &\livelinki{chap:DWATcalldatalocationofcallparameter}
            {Address of the value pointed to by an argument passed in a call}
-           {address of the value pointed to by an argument passed in a call}
+           {address of the value pointed to by an argument}
            \index{call site!address of the value pointed to by an argument} \\
 \DWATcalldatavalueTARG{}
 &\livelinki{chap:DWATcalldatavalueofcallparameter}
            {Value pointed to by an argument passed in a call}
-           {value pointed to by an argument passed in a call}
+           {value pointed to by an argument}
            \index{call site!value pointed to by an argument} \\
 \DWATcallfileTARG
 &\livelinki{chap:DWATcallfilefilecontaininginlinedsubroutinecall}
@@ -242,17 +242,17 @@ The attributes are listed in Table \referfol{tab:attributenames}.
 \DWATcalloriginTARG{}
 &\livelinki{chap:DWATcalloriginofcallsite}
            {Subprogram called in a call}
-           {subprogram called in a call}
+           {subprogram called}
            \index{call site!subprogram called} \\
 \DWATcallparameterTARG{}
 &\livelinki{chap:DWATcallparameterofcallparameter}
            {Parameter entry in a call}
-           {parameter entry in a call}
+           {parameter entry}
            \index{call site!parameter entry} \\
 \DWATcallpcTARG{}
 &\livelinki{chap:DWATcallpcofcallsite}
            {Address of the call instruction in a call}
-           {address of the call instruction in a call}
+           {address of call instruction}
            \index{call site!address of the call instruction} \\
 \DWATcallreturnpcTARG{}
 &\livelinki{chap:DWATcallreturnpcofcallsite}
@@ -267,17 +267,17 @@ The attributes are listed in Table \referfol{tab:attributenames}.
 \DWATcalltargetTARG{}
 &\livelinki{chap:DWATcalltargetofcallsite}
            {Address of called routine in a call}
-           {address of called routine in a call}
+           {address of called routine}
            \index{call site!address of called routine} \\
 \DWATcalltargetclobberedTARG{}
 &\livelinki{chap:DWATcalltargetclobberedofcallsite}
            {Address of called routine, which may be clobbered, in a call}
-           {address of called routine, which may be clobbered, in a call}
+           {address of called routine, which may be clobbered}
            \index{call site!address of called routine, which may be clobbered} \\
 \DWATcallvalueTARG{}
 &\livelinki{chap:DWATcallvalueofcallparameter}
            {Argument value passed in a call}
-           {argument value passed in a call}
+           {argument value passed}
            \index{call site!argument value passed} \\
 \DWATcommonreferenceTARG
 &\livelinki{chap:commonreferencecommonblockusage}{Common block usage}{common block usage} \\
@@ -293,7 +293,7 @@ The attributes are listed in Table \referfol{tab:attributenames}.
 \DWATcontainingtypeTARG
 &\livelinki{chap:DWATcontainingtypecontainingtypeofpointertomembertype}{Containing type of pointer to member type}{containing type of pointer to member type} \\
 \DWATcountTARG
-&\livelinki{chap:DWATcountelementsofsubrangetype}{Elements of subrange type}{elements ofbreg subrange type} \\
+&\livelinki{chap:DWATcountelementsofsubrangetype}{Elements of subrange type}{elements of breg subrange type} \\
 \DWATdatabitoffsetTARG
 &\livelinki{chap:DWATdatabitoffsetbasetypebitlocation}{Base type bit location}{base type bit location} \\
 &\livelinki{chap:DWATdatabitoffsetdatamemberbitlocation}{Data member bit location}{data member bit location} \\
@@ -409,7 +409,7 @@ The attributes are listed in Table \referfol{tab:attributenames}.
 \DWATrangesTARG
 &\livelinki{chap:DWATrangesnoncontiguousrangeofcodeaddresses}{Non-contiguous range of code addresses}{non-contiguous range of code addresses} \\
 \DWATrangesbaseTARG
-&\livelinki{chap:DWATrangesbaseforrangelists}{Base offset for range lists}{Ranges lists} \\
+&\livelinki{chap:DWATrangesbaseforrangelists}{Base offset for range lists}{ranges lists} \\
 \DWATrankTARG
 &\livelinki{chap:DWATrankofdynamicarray}{Dynamic number of array dimensions}{dynamic number of array dimensions} \\
 \DWATrecursiveTARG
@@ -709,12 +709,11 @@ of the entry to which the attribute is attached.
 
 \section{Target Addresses}
 \label{chap:targetaddresses}
-Many places in this document 
-refer
-\addtoindexx{address size|see{size of an address}}
-to the size 
-of an
+Many places in this document refer to the size of an
+\addtoindexx{size of an address|see{\textit{also} address\_size}}
 \addtoindexi{address}{size of an address}
+\addtoindexx{address size|see{size of an address}}
+\addtoindexx{address size|see{\textit{also} \texttt{address\_size}}}
 on the target architecture (or equivalently, target machine)
 to which a DWARF description applies. For processors which
 can be configured to have different address sizes or different
@@ -860,14 +859,14 @@ interpreted by the consumer as a relocatable address
 (for example, offsets to thread-local storage).}
 
 \itembfnl{\DWOPconsttypeTARG}
-The \DWOPconsttypeNAME{} operation takes three operands. The first operand is an
-unsigned LEB128 integer that represents the offset of a debugging
+The \DWOPconsttypeNAME{} operation takes three operands. The first operand 
+is an unsigned LEB128 integer that represents the offset of a debugging
 information entry in the current compilation unit, which must be a
 \DWTAGbasetype{} entry that provides the type of the constant provided. The
-second operand is 1-byte unsigned integer that represents the size \texttt{n} of the
-constant, which may not be larger than the size of the largest supported
-base type of the target machine. The third operand is a block of \texttt{n} bytes to
-be interpreted as a value of the referenced type.
+second operand is 1-byte unsigned integer that specifies the size of the
+constant value, which may not be larger than the size of the largest supported
+base type of the target machine. The third operand is a block of specified 
+size that is to be interpreted as a value of the referenced type.
 
 \textit{While the size of the constant could be inferred from the base type
 definition, it is encoded explicitly into the expression so that the
@@ -1392,10 +1391,10 @@ on the location stack or any of its values.
 
 \itembfnl{\DWOPentryvalueNAME}
 The \DWOPentryvalueTARG{} operation pushes a value that had a known location
-upon entering the current subprogram.  It uses two operands: an 
+upon entering the current subprogram.  It has two operands: an 
 unsigned LEB128\addtoindexx{LEB128!unsigned} length, followed by 
 a block containing a DWARF expression or
-a simple register location description.  The length gives the length
+a simple register location description.  The length operand specifies the length
 in bytes of the block.  If the block contains a register location
 description, \DWOPentryvalueNAME{} pushes the value that register had upon
 entering the current subprogram.  If the block contains a DWARF expression,
@@ -2284,7 +2283,7 @@ address space.
 
 \textit{Some systems support different classes of 
 addresses
-\addtoindexx{address class!attribute}. 
+\addtoindexx{address class}. 
 The
 address class may affect the way a pointer is dereferenced
 or the way a subroutine is called.}
@@ -2654,10 +2653,10 @@ offset within the \dotdebugranges{} section for the compilation
 unit. The offset given by the \DWATranges{} attribute is
 relative to that base.
 
-\textit{The \DWATrangesbase{} attribute is new in \addtoindex{DWARF Version 5}.
-The advantage of this attribute is that is reduces the number of
+\textit{The \DWATrangesbase{} attribute is new in \DWARFVersionV.
+The advantage of this attribute is that it reduces the number of
 object language relocations needed for references to the \dotdebugranges{}
-section from one for each reference to a single relocation that
+section from one for each range entry to a single relocation that
 applies for the entire compilation unit.}
 
 Each entry in a \addtoindex{range list} is either a 
index 44a35eb..df20014 100644 (file)
@@ -147,8 +147,8 @@ together with new forms of attribute value for referencing these sections.
 This enhances DWARF support for very large programs.
 \item Replace the \dotdebugmacinfo{} macro information representation with
 a much more compact \dotdebugmacro{} representation.
-\item Add a new debugging information entry and related attributes and
-DWARF expression operators for describing call information, 
+\item Add a new debugging information entry, related attributes and
+DWARF expression operators, to describe call information, 
 including identification of tail calls and tail recursion.
 \item Add a new attribute, \DWATnoreturn{}, to identify a subprogram that 
 does not return to its caller.
@@ -162,6 +162,11 @@ Julia, Modula 3, Ocaml, Rust, OpenCL and Swift.
 
 DWARF Version 5 is compatible with DWARF Version 4 except as follows:
 \begin{itemize}
+\item A new field is included in the line number table header to allow use of an MD5
+hash to validate source file version in use.
+\item New operand forms for attribute values are defined (\DWFORMstrx, \DWFORMaddrx).
+(Because a pre-DWARF Version 5 consumer will not be able to interpret these even to
+ignore and skip over them, they must be considered incompatible.)
 \item A location list entry (see Section \refersec{chap:locationlists}) with 
 the address range \mbox{(0, \doublequote{-1})} is defined as the new default location 
 list entry.
@@ -169,12 +174,15 @@ list entry.
 attribute is defined to always describe the size of the string type. (Previously
 it described the size of the optional string length data field if the \DWATstringlength{}
 attribute was present.)
-\item The macro information representation is completely new; however, producers 
-and consumers can optionally continue to support the older representation. While
-the two representations cannot both be used in the same compilation unit, they can
-co-exist in executable or shared images.
 \end{itemize}
 
+While not strictly an incompatibility, the macro information 
+representation is completely new; further, producers 
+and consumers may optionally continue to support the older 
+representation. While the two representations cannot both be 
+used in the same compilation unit, they can co-exist in 
+executable or shared images.
+
 \needlines{4}
 \section{Changes from Version 3 to Version 4}
 \addtoindexx{DWARF Version 4}
index 23842dc..88cc6e0 100644 (file)
@@ -93,7 +93,7 @@ Each set begins with a header containing four values:
 \begin{enumerate}[1. ]
 
 \item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
-\addtoindexx{unit\_length}
+\addttindexx{unit\_length}
 The total length of the all of the entries for that set,
 not including the length field itself 
 (see Section \refersec{datarep:initiallengthvalues}).
@@ -177,18 +177,18 @@ The offset from the
 beginning of the \dotdebuginfo{} section of the
 compilation unit header referenced by the set.
 
-\item address\_size (\addtoindex{ubyte}) \\
+\item \texttt{address\_size} (\addtoindex{ubyte}) \\
 The \addtoindex{size of an address}
 in bytes on
-\addtoindexx{address\_size}
+\addttindexx{address\_size}
 the target architecture. For 
 \addtoindexx{address space!segmented}
 segmented addressing, this is
 the size of the offset portion of the address.
 
-\item segment\_size (\addtoindex{ubyte}) \\
+\item \texttt{segment\_size} (\addtoindex{ubyte}) \\
 The size of a segment selector in
-\addtoindexx{segment\_size}
+\addttindexx{segment\_size}
 bytes on the target architecture. If the target system uses
 a flat address space, this value is 0.
 
@@ -203,7 +203,7 @@ 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 
-\addtoindex{segment\_size} value
+\addttindex{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
@@ -802,7 +802,7 @@ To decode a special opcode, subtract the \addttindex{opcode\_base} from
 the opcode itself to give the \textit{adjusted opcode}. 
 The \textit{operation advance} 
 is the result of the adjusted opcode divided by the
-\texttt{line\_range}. The new \texttt{address} and 
+\addttindex{line\_range}. The new \texttt{address} and 
 \addttindex{op\_index} values are given by
 \begin{alltt}
   \textit{adjusted opcode} = opcode \dash opcode\_base
@@ -1425,7 +1425,7 @@ user on the command line.
 
 \textit{Debuggers often need to be able to view and modify the 
 state of any subroutine activation that is
-\addtoindexx{activation!call frame}
+\addtoindexx{activation of call frame}
 on the call stack. An activation consists of:}
 
 \begin{itemize}
@@ -2100,7 +2100,7 @@ appropriate size.
 
 \textit{To determine the virtual unwind rule set for a given location
 (L1), one searches through the FDE headers looking at the
-\texttt{initial\_location} and \texttt{address\_range} values to see if L1 is
+\addttindex{initial\_location} and \addttindex{address\_range} values to see if L1 is
 contained in the FDE. If so, then:}
 \begin{enumerate}[1. ]
 
@@ -2118,7 +2118,7 @@ instruction is encountered, then compute a new location value
 to step 2.}
 
 \item \textit{ The end of the instruction stream can be thought
-of as a \DWCFAsetloc{} (\texttt{initial\_location + address\_range})
+of as a \DWCFAsetloc{} (\addttindex{initial\_location} + \addttindex{address\_range})
 instruction. Note that the FDE is ill-formed if L2 is less
 than L1.}
 
@@ -2144,6 +2144,7 @@ If a Return Address register is defined in the virtual
 unwind table, and its rule is undefined (for example, by
 \DWCFAundefined), then there is no return address and no
 call address, and the virtual unwind of stack activations
+\addtoindexx{activation of call frame}
 is complete.
 
 \textit{In most cases the return address is in the same context as the
index 6ef456b..288b25d 100644 (file)
@@ -153,7 +153,7 @@ Language name & Meaning\\ \hline
 \DWLANGCobolseventyfourTARG & ISO COBOL:1974 \addtoindexx{COBOL:1974 (ISO)} \\
 \DWLANGCoboleightyfiveTARG  & ISO COBOL:1985 \addtoindexx{COBOL:1985 (ISO)} \\
 \DWLANGDTARG{}~\dag & D \addtoindexx{D language} \\
-\DWLANGDylanTARG~\dag & Dylan \addtoindexx{Dylan language} \\
+\DWLANGDylanTARG~\dag & Dylan \addtoindexx{Dylan} \\
 \DWLANGFortranseventysevenTARG & ISO FORTRAN:1977 \addtoindexx{FORTRAN:1977 (ISO)} \\
 \DWLANGFortranninetyTARG       & ISO Fortran:1990 \addtoindexx{Fortran:1990 (ISO)} \\
 \DWLANGFortranninetyfiveTARG   & ISO Fortran:1995 \addtoindexx{Fortran:1995 (ISO)} \\
@@ -1168,8 +1168,7 @@ not have an attribute for the return type.  }
 
 \textit{Debugging information entries for declarations of \addtoindex{C++} 
 member functions with an 
-\addtoindex{\texttt{auto} return type} specifier should use an unspecified 
-type entry (see 
+\autoreturntype{} specifier should use an unspecified type entry (see 
 Section \refersec{chap:unspecifiedtypeentries}). 
 The debugging information entry for the corresponding definition
 should provide the deduced return type.  This practice causes the description of
@@ -1222,7 +1221,7 @@ There is insufficient reason to change this.}
 Subroutines 
 and 
 entry
-\addtoindexx{address class!attribute}
+\addtoindexx{address class attribute}
 points 
 \hypertarget{chap:DWATaddressclasssubroutineorsubroutinetype}{}
 may also have 
@@ -1871,7 +1870,7 @@ outer subroutine.
 \item The concrete instance tree for any inlined or 
 \addtoindexx{out-of-line instance}
 out-of-line
-\addtoindexx{out-of-line-instance|see{concrete out-of-line-instance}}
+\addtoindexx{out-of-line instance|see{\textit{also} concrete out-of-line instance}}
 expansion of the nested subroutine is described within a
 concrete instance tree for the outer subroutine according
 to the rules in 
index cb5ed7c..9ca9705 100644 (file)
@@ -53,7 +53,7 @@ format would be represented by a change in the
 \dotdebugranges{}   & - & * & * & 5 \\
 \dotdebugstr{}      & * & * & * & * \\
 \dotdebugstroffsets & - & - & - & 5 \\
-\addtoindexi{\texttt{.debug\_types}}{\texttt{.debug\_types} (DWARF Version 4)}
+\addtoindexi{\texttt{.debug\_types}}{\texttt{.debug\_types} (Version 4)}
                     & - & - & 4 & - \\
 
 \hspace{3.5cm}\textit{(.dwo sections)}\\
index 31fe10b..674c753 100644 (file)
@@ -1,6 +1,7 @@
 \chapter[Split DWARF Objects (Informative)]{Split DWARF Objects (Informative)}
 \label{app:splitdwarfobjectsinformative}
-
+\addtoindexx{DWARF compression}
+\addtoindex{DWARF duplicate elimination}
 With the traditional DWARF format, debug information is designed
 with the expectation that it will be processed by the linker to
 produce an output binary with complete debug information, and
@@ -33,7 +34,8 @@ require relocation are written to the relocatable object file as
 usual, and are linked into the final executable. The sections
 that do not require relocation, however, can be written to the
 relocatable object (.o) file but ignored by the linker, or they
-can be written to a separate DWARF object (dwo{}) file.
+can be written to a separate DWARF object (.dwo{}) 
+\addtoindexx{\texttt{.dwo} file extension} file.
 
 \needlines{4}
 The optional set of debugging sections includes the following:
@@ -277,5 +279,5 @@ used to locate the line number tables.
 
 \section{DWARF Package File Example}
 \label{app:dwarfpackagefileexample}
-
+\addtoindex{DWARF duplicate elimination!examples}
 [TBD]
index 399fa89..50b1537 100644 (file)
@@ -101,7 +101,8 @@ of zero is assumed.
 \textit{Attribute 
 \DWATdatabitoffset{} 
 is 
-\addtoindexx{bit offset attribute}
+\addtoindexx{bit offset attribute (Version 3)}
+\addtoindexx{bit offset attribute (Version 3)|see{\textit{also} data bit offset attribute}}
 new 
 \addtoindexx{data bit offset attribute}
 in 
@@ -113,11 +114,11 @@ It
 replaces the attribute 
 \DWATbitoffset{} 
 when used for base
-\addtoindexx{bit offset attribute (V3)}
-types as defined in DWARF V3 and earlier.
+\addtoindexx{bit offset attribute (Version 3)}
+types as defined in \DWARFVersionIII{} and earlier.
 \DWATbitoffset{}
 is deprecated for use in base types in DWARF Version 4 and later.
-See Section 5.1 in the DWARF Version 4
+See Section 5.1 in the \DWARFVersionIV{}
 specification for a discussion of compatibility considerations.}
 
 \begin{table}[!here]
@@ -377,8 +378,7 @@ type is incomplete (the name is declared as a type but the
 definition is deferred to a separate compilation unit).
 
 \addtoindex{C++} permits using the 
-\addtoindexi{\texttt{auto}}{\texttt{auto return type}} specifier for the return 
-type of a member function declaration. 
+\autoreturntype{} specifier for the return type of a member function declaration. 
 The actual return type is deduced based on the definition of the 
 function, so it may not be known when the function is declared.  The language 
 implementation can provide an unspecified type entry with the name \texttt{auto} which 
@@ -428,7 +428,7 @@ pointer or \addtoindex{reference type}
 \DWTAGrvaluereferencetype) 
 % Another instance of no-good-place-to-put-index entry.
 may
-\addtoindexx{address class!attribute} 
+\addtoindexx{address class attribute} 
 have 
 \hypertarget{chap:DWATadressclasspointerorreferencetypes}{}
 a 
@@ -1432,7 +1432,7 @@ the entry describes a non\dash static member function whose
 object formal parameter has a type that has an equivalent
 const\dash volatile qualification.
 
-\textit{In \addtoindex{C++11}, non-static member functions can also have one of the
+\textit{In \addtoindex{C++:2011 (ISO)}, non-static member functions can also have one of the
 ref-qualifiers, \& and \&\&. They do not change the type of the
 \doublequote{\texttt{this}}-pointer, but they affect the types of object values the
 function can be invoked on.}
@@ -1465,7 +1465,7 @@ a name attribute giving the name of the function member whose
 definition they represent.  
 Similarly, such entries do not need to contain a return type attribute, 
 unless the return type on the declaration was unspecified (for example, the 
-declaration used the \addtoindex{C++} \addtoindex{\texttt{auto} return type} specifier).
+declaration used the \addtoindex{C++} \autoreturntype{} specifier).
 
 \needlines{5}
 \subsection{Class Template Instantiations}
@@ -1739,7 +1739,7 @@ represented on the target system.
 
 
 If the enumeration type occurs as the description of a
-\addtoindexx{enumeration type endry!as array dimension}
+\addtoindexx{enumeration type entry!as array dimension}
 dimension of an array type, and the stride for that dimension
 \hypertarget{chap:DWATbytestrideenumerationstridedimensionofarraytype}{}
 is different than what would otherwise be determined, then
@@ -1839,7 +1839,7 @@ tag \DWTAGunspecifiedparameters.
 \textit{\addtoindex{C++} const-volatile qualifiers are encoded as 
 part of the type of the
 \doublequote{\texttt{this}}-pointer. 
-\addtoindex{C++11} reference and rvalue-reference qualifiers are encoded using
+\addtoindex{C++:2011 (ISO)} reference and rvalue-reference qualifiers are encoded using
 the \DWATreference{} and \DWATrvaluereference{} attributes, respectively. 
 See also Section \refersec{chap:memberfunctionentries}.}
 
@@ -2207,13 +2207,9 @@ The file type entry has
 a \DWATtype{} attribute describing
 the type of the objects contained in the file.
 
-The file type entry also 
-\addtoindexx{byte size}
-has 
-\addtoindexx{bit size}
-a 
-\DWATbytesize{} or
-\DWATbitsize{} attribute, whose value 
+The file type entry also has a 
+\DWATbytesize{}\addtoindexx{byte size attribute} or
+\DWATbitsize{}\addtoindexx{bit size attribute} attribute, whose value 
 (see Section \refersec{chap:staticanddynamicvaluesofattributes})
 is the amount of storage need to hold a value of the file type.