Save changes due to committe review... Big changes are due to
authorRon Brender <ron.brender@gmail.com>
Thu, 7 May 2015 14:35:27 +0000 (10:35 -0400)
committerRon Brender <ron.brender@gmail.com>
Thu, 7 May 2015 14:35:27 +0000 (10:35 -0400)
comments from Eager plus moving some DWARF stack related examples
into Appendix D.

Signed-off-by: Ron Brender <ron.brender@gmail.com>
12 files changed:
dwarf5/latexdoc/changesummary.tex
dwarf5/latexdoc/dataobject.tex
dwarf5/latexdoc/datarepresentation.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/splitobjects.tex
dwarf5/latexdoc/typeentries.tex

index de9e40d..83ee2d1 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
+5/3-7/2015      & More editorial work II \\
 4/24-26/2015    & More editorial work \\
 4/4-23/2015     & Editorial changes from Committee review \\
 3/3/2015        & 150108.1 (accelerated access) \\
index 389d38e..b77195e 100644 (file)
@@ -32,7 +32,7 @@ whose value is a null-terminated string containing the data object
 name as it appears in the source program.
 
 If a variable entry describes an 
-\addtoindex{anonymous union},
+\addtoindex{anonymous union} or other construct,
 the name attribute is omitted or its value describes a single
 zero byte.
 
@@ -44,11 +44,11 @@ is a \livelink{chap:classflag}{flag}, if the name
 of a variable is visible outside of its enclosing compilation
 unit.  
 
-\textit{The definitions of \addtoindex{C++} static data members of structures
-or classes are represented by variable entries \nolink{flagged} as
-external. Both file static and local variables in \addtoindex{C} and \addtoindex{C++}
-are represented by non-external variable entries.
-}
+\textit{The definitions of \addtoindex{C++} static data members 
+of structures or classes are represented by variable entries 
+\nolink{flagged} as external. Both file static and local variables 
+in \addtoindex{C} and \addtoindex{C++} are represented by 
+non-external variable entries.}
 
 \item A \DWATdeclaration{} attribute, 
 \addtoindexx{declaration attribute}
@@ -66,25 +66,27 @@ entry representing the definition of a variable (that is,
 with no 
 \DWATdeclaration{} attribute),
 or if the location attribute is present but has
-an empty location description (as described in Section \refersec{chap:locationdescriptions}),
+an empty location description (as described in Section 
+\refersec{chap:locationdescriptions}),
 \addtoindexx{unallocated variable}
 the variable is assumed to exist in the source code but not
 in the executable program (but see number 10, below).
 
-In a variable entry representing a non-defining declaration of a variable, the location
-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.
+In a variable entry representing a non-defining declaration 
+of a variable, the location specified supersedes the location 
+specified by the defining declaration but only within the
+scope of the variable entry; if no location is specified, 
+then the location specified in the defining declaration 
+applies.
 
-\textit{This can occur, for example, for a \addtoindex{C} or \addtoindex{C++}
-external variable (one that is defined and allocated in another compilation unit) 
-and whose location varies in the current unit due to optimization.}
+\textit{This can occur, for example, for a \addtoindex{C} 
+or \addtoindex{C++} external variable (one that is defined 
+and allocated in another compilation unit) and whose location 
+varies in the current unit due to optimization.}
 
 The location of a variable may be further specified with 
 \addtoindexx{segment attribute!and data segment}
-a 
-\DWATsegment{} attribute, if
-appropriate.
+a \DWATsegment{} attribute, if appropriate.
 
 \item A \DWATtype{} attribute describing the type of the variable,
 constant or formal parameter.
@@ -191,7 +193,7 @@ the beginning of that containing scope, then the scope of the
 object is specified using a value of class constant. If the
 containing scope is contiguous, the value of this attribute
 is the offset in bytes of the beginning of the scope for the
-object from the low pc value of the debugging information
+object from the low PC value of the debugging information
 entry that defines its scope. If the containing scope
 is non-contiguous 
 (see \refersec{chap:noncontiguousaddressranges})
@@ -282,16 +284,16 @@ for different architectures.
 \item A \DWATconstexpr{} attribute, 
 which 
 \hypertarget{chap:DWATconstexprcompiletimeconstantobject}{}
-is a \livelink{chap:classflag}{flag}, if a
+is a \CLASSflag, if a
 variable entry represents a \addtoindex{C++} object declared with the
 \texttt{constexpr} specifier. This attribute indicates that the
 variable can be evaluated as a compile\dash time constant.  
 
 \textit{In \addtoindex{C++},
-a variable declared with \texttt{constexpr} is implicitly \texttt{const}. Such a
-variable has a \DWATtype{} attribute whose value is a 
-\livelink{chap:classreference}{reference}
-to a debugging information entry describing a const qualified type.}
+a variable declared with \texttt{constexpr} is implicitly 
+\texttt{const}. Such a variable has a \DWATtype{} attribute 
+whose value is a \CLASSreference{} to a debugging information 
+entry describing a \texttt{const} qualified type.}
 
 \item A \DWATlinkagename{} attribute for a 
 variable or constant entry as described in 
@@ -301,11 +303,12 @@ Section \refersec{chap:linkagenames}.
 
 \section{Common Block Entries}
 \label{chap:commonblockentries}
-A Fortran \livetargi{chap:fortrancommonblock}{common}{Fortran!common block} \livetargi{chap:commonblockentry}{block}{common block entry} 
+A Fortran 
+\livetargi{chap:fortrancommonblock}{common}{Fortran!common block}
+\livetargi{chap:commonblockentry}{block}{common block entry} 
 may 
 \addtoindexx{Fortran!common block}
-be described by a debugging
-information entry with the 
+be described by a debugging information entry with the 
 tag \DWTAGcommonblockTARG. 
 
 The common \nolink{block} 
index ca9892b..9d128ab 100644 (file)
@@ -1396,7 +1396,7 @@ Table \referfol{tab:attributeencodings}.
             \addtoindexx{byte stride attribute}  \\
 \DWATentrypc&0x52&\livelink{chap:classaddress}{address}, 
         \livelink{chap:classconstant}{constant} 
-            \addtoindexx{entry pc attribute}  \\
+            \addtoindexx{entry PC attribute}  \\
 \DWATuseUTFeight&0x53&\livelink{chap:classflag}{flag} 
             \addtoindexx{use UTF8 attribute}\addtoindexx{UTF-8}  \\
 \DWATextension&0x54&\livelink{chap:classreference}{reference} 
@@ -1494,7 +1494,7 @@ Table \referfol{tab:attributeencodings}.
 \DWATcallalltailcalls~\ddag &0x7c&\CLASSflag
         \addtoindexx{all tail calls summary attribute} \\
 \DWATcallreturnpc~\ddag &0x7d &\CLASSaddress
-        \addtoindexx{call return pc attribute} \\
+        \addtoindexx{call return PC attribute} \\
 \DWATcallvalue~\ddag &0x7e &\CLASSexprloc
         \addtoindexx{call value attribute} \\
 \DWATcallorigin~\ddag &0x7f &\CLASSexprloc
@@ -1502,7 +1502,7 @@ Table \referfol{tab:attributeencodings}.
 \DWATcallparameter~\ddag &0x80 &\CLASSreference
         \addtoindexx{call parameter attribute} \\
 \DWATcallpc~\ddag &0x81 &\CLASSaddress
-        \addtoindexx{call pc attribute} \\
+        \addtoindexx{call PC attribute} \\
 \DWATcalltailcall~\ddag &0x82 &\CLASSflag
         \addtoindexx{call tail call attribute} \\
 \DWATcalltarget~\ddag &0x83 &\CLASSexprloc
@@ -1654,7 +1654,7 @@ can be anything. Depending on context, it may
 be a signed integer, an unsigned integer, a floating\dash point
 constant, or anything else. A consumer must use context to
 know how to interpret the bits, which if they are target
-machine data (such as an integer or floating point constant)
+machine data (such as an integer or floating-point constant)
 will be in target machine byte\dash order.
 
 \textit{If one of the \DWFORMdataTARG\textless n\textgreater 
index afa7e0e..e450671 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}{April 26, 2015}
+\newcommand{\docdate}{May 7, 2015}
 %
 \usepackage{ifthen}
 \newboolean{isdraft}
@@ -149,6 +149,8 @@ escapeinside={\%*}{*)}     % if you want to add a comment within your code
 
 % Better naming for the lowest level section header
 \newcommand{\subsubsubsection}[1]{\paragraph{#1}~\newline}
+%\newcommand{\subsubsubsubsection}[1]{\subparagraph{#1}.~}  %% Huh?
+\newcommand{\subsubsubsubsection}[1]{\textbf{#1}.~~}
 %\newcommand{\subsubsubsection}         %% Has to be in a style file--ugh...
 %   {\@startsection{subsubsubsection}{4}{0mm}{-\baselineskip}{\baselineskip}{\normalfont\normalsize\itshap}}
 
@@ -218,14 +220,14 @@ escapeinside={\%*}{*)}     % if you want to add a comment within your code
 \href{http://www.dwarfstd.org}{\dwf}
 \href{http://www.dwarfstd.org}{Committee}
 \\
-\vspace{0.3cm} 
+\vspace{0.5cm} 
 \url{http://www.dwarfstd.org}
 \\
-\vspace{3cm}
-\textbf{\docdate}
+\vspace{2cm}
+{\Large \textbf{\docdate}}
 \\
 \ifthenelse{\boolean{isdraft}}{
-       \vspace{1cm}
+       \vspace{2cm}
        \draftmark}
        {}
 \end{center}
@@ -303,10 +305,10 @@ escapeinside={\%*}{*)}     % if you want to add a comment within your code
 \setcounter{secnumdepth}{5}
 
 \include{introduction}                  %\emptypage
-\include{generaldescription}            \emptypage
+\include{generaldescription}            %\emptypage
 \include{programscope}                  \emptypage
 \include{dataobject}                    %\emptypage
-\include{typeentries}                   \emptypage
+\include{typeentries}                   %\emptypage
 \include{otherdebugginginformation}    \emptypage
 \include{datarepresentation}            %\emptypage
 
index 52ca830..4cc14d4 100644 (file)
 \newcommand{\MDfive}{\livelink{def:MDfive}{MD5}}
 \newcommand{\COMDAT}{\addtoindex{COMDAT}}
 \newcommand{\autoreturntype}{\texttt{auto} return type\index{auto return type@\texttt{auto} return type}}
+\newcommand{\specialaddresstype}{\livelink{chap:specialaddresstype}{special address type}}
 %
 % Anti-ligature commands added because \/ and {} don't work for unknown reasons
 % nor does the microtext package DisableLigatures command...???
index 56a4165..3ee9890 100644 (file)
@@ -5,9 +5,12 @@ The following sections provide examples that illustrate
 various aspects of the DWARF debugging information format.
 
 
-\section{Compilation Units and Abbreviations Table Example}
-\label{app:compilationunitsandabbreviationstableexample}
+\section{General Description Examples}
+\label{app:generaldescriptionexamples}
+
 
+\subsection{Compilation Units and Abbreviations Table Example}
+\label{app:compilationunitsandabbreviationstableexample}
 
 Figure \refersec{fig:compilationunitsandabbreviationstable}
 depicts the relationship of the abbreviations tables contained
@@ -208,6 +211,137 @@ Abbreviation Table: \dotdebugabbrev{}
 % Ensures we get the above float out before we go on.
 \clearpage
 
+\subsection{DWARF Stack Operation Examples}
+\label{app:dwarfstackoperationexamples}
+\textit {The 
+\addtoindexx{DWARF expression!examples}
+stack operations defined in 
+Section \refersec{chap:stackoperations}.
+are fairly conventional, but the following
+examples illustrate their behavior graphically.}
+
+\begin{longtable}[c]{rrcrr} 
+\multicolumn{2}{c}{Before} & Operation & \multicolumn{2}{c}{After} \\
+\hline
+\endhead
+\endfoot
+0& 17& \DWOPdup{} &0 &17 \\*
+1&   29& &  1 & 17 \\*
+2& 1000 & & 2 & 29\\*
+& & &         3&1000\\
+
+& & & & \\
+0 & 17 & \DWOPdrop{} & 0 & 29 \\*
+1 &29  &            & 1 & 1000 \\*
+2 &1000& & &          \\
+
+& & & & \\
+0 & 17 & \DWOPpick, 2 & 0 & 1000 \\*
+1 & 29 & & 1&17 \\*
+2 &1000& &2&29 \\*
+  &    & &3&1000 \\
+
+& & & & \\
+0&17& \DWOPover&0&29 \\*
+1&29& &  1&17 \\*
+2&1000 & & 2&29\\*
+ &     & & 3&1000 \\
+
+& & & & \\
+0&17& \DWOPswap{} &0&29 \\*
+1&29& &  1&17 \\*
+2&1000 & & 2&1000 \\
+
+& & & & \\
+0&17&\DWOProt{} & 0 &29 \\*
+1&29 & & 1 & 1000 \\*
+2& 1000 & &  2 & 17 \\
+\end{longtable}
+
+\subsection{DWARF Location Description Examples}
+\label{app:dwarflocationdescriptionexamples}
+
+Following are examples of DWARF operations used to form location descriptions:
+
+\newcommand{\descriptionitemnl}[1]
+        {\vspace{0.5\baselineskip}\item[#1]\mbox{}\\\vspace{0.5\baselineskip}}
+\begin{description}
+\descriptionitemnl{\DWOPregthree}
+The value is in register 3.
+
+\descriptionitemnl{\DWOPregx{} 54}
+The value is in register 54.
+
+\descriptionitemnl{\DWOPaddr{} 0x80d0045c}
+The value of a static variable is at machine address 0x80d0045c.
+
+\descriptionitemnl{\DWOPbregeleven{} 44}
+Add 44 to the value in register 11 to get the address of an automatic
+variable instance.
+
+\needlines{4}
+\descriptionitemnl{\DWOPfbreg{} -50}
+Given a \DWATframebase{} value of
+\doublequote{\DWOPbregthirtyone{} 64,} this example
+computes the address of a local variable that is -50 bytes from a
+logical frame pointer that is computed by adding 64 to the current
+stack pointer (register 31).
+
+\descriptionitemnl{\DWOPbregx{} 54 32 \DWOPderef}
+A call-by-reference parameter whose address is in the word 32 bytes
+from where register 54 points.
+
+\descriptionitemnl{\DWOPplusuconst{} 4}
+A structure member is four bytes from the start of the structure
+instance. The base address is assumed to be already on the stack.
+
+\descriptionitemnl{\DWOPregthree{} \DWOPpiece{} 4 \DWOPregten{} \DWOPpiece{} 2}
+A variable whose first four bytes reside in register 3 and whose next
+two bytes reside in register 10.
+
+\needlines{4}
+\descriptionitemnl{\DWOPregzero{} \DWOPpiece{} 4 \DWOPpiece{} 4 \DWOPfbreg{} -12 \DWOPpiece{} 4}
+\vspace{-2\parsep}A twelve byte value whose first four bytes reside in register zero,
+whose middle four bytes are unavailable (perhaps due to optimization),
+and whose last four bytes are in memory, 12 bytes before the frame
+base.
+
+\descriptionitemnl{\DWOPbregone{} 0 \DWOPbregtwo{} 0 \DWOPplus{} \DWOPstackvalue{} }
+Add the contents of r1 and r2 to compute a value. This value is the
+\doublequote{contents} of an otherwise anonymous location.
+
+\needlines{4}
+\descriptionitemnl{\DWOPlitone{} \DWOPstackvalue{} \DWOPpiece{} 4 \DWOPbregthree{} 0 \DWOPbregfour{} 0}
+\vspace{-3\parsep}\descriptionitemnl{
+\hspace{0.5cm}\DWOPplus{} \DWOPstackvalue{} \DWOPpiece{} 4 }
+The object value is found in an anonymous (virtual) location whose
+value consists of two parts, given in memory address order: the 4 byte
+value 1 followed by the four byte value computed from the sum of the
+contents of r3 and r4.
+
+\descriptionitemnl{\DWOPentryvalue{} 1 \DWOPregone{} \DWOPstackvalue }
+The value register 1 had upon entering the current subprogram.
+
+\descriptionitemnl{\DWOPentryvalue{} 2 \DWOPbregone{} 0 \DWOPstackvalue }
+The value register 1 had upon entering the current subprogram (same as the previous example).
+%Both of these location descriptions evaluate to the value register 1 had upon
+%entering the current subprogram.
+
+%FIXME: The following gets an undefined control sequence error for reasons unknown... 
+%\descriptionitemnl{\DWOPentryvalue{} 1 \DWOPregthirtyone{} \DWOPregone{} \DWOPadd{} \DWOPstackvalue }
+%The value register 31 had upon entering the current subprogram
+%plus the value register 1 currently has.
+
+\descriptionitemnl{\DWOPentryvalue{} 3 \DWOPbregfour{} 16 \DWOPderef{} \DWOPstackvalue }
+%FIXME: similar undefined as just above
+%\descriptionitemnl{\DWOPentryvalue{} 6 \DWOPentryvalue{} 1 \DWOPregfour{} \DWOPplusuconst{} 16 \DWOPderef{} \DWOPstackvalue }
+%These two location expressions do the same thing, p
+Add 16 to the value register 4 had upon entering the current subprogram
+to form an address and then push the value of the memory location at that address.
+
+\end{description}
+
+\clearpage
 \section{Aggregate Examples}
 \label{app:aggregateexamples}
 
@@ -1207,6 +1341,115 @@ Figure~\ref{fig:packedrecordexampledwarfdescription}: Packed record example: DWA
 \end{center}
 \end{figure}
 
+\clearpage
+\subsection{C/C++ Bit-Field Examples}
+\label{app:ccppbitfieldexamples}
+\textit{Bit fields\addtoindexx{bit fields} in \addtoindex{C} 
+and \addtoindex{C++} typically require the use of the
+\DWATdatabitoffset{}\addtoindexx{data bit offset}
+and \DWATbitsize{}\addtoindexx{data bit size} attributes.}
+
+\needlines{6}
+\textit{This Standard uses the following bit numbering and direction
+conventions in examples. These conventions are for illustrative
+purposes and other conventions may apply on particular
+architectures.}
+\begin{itemize}
+\item \textit{For big\dash endian architectures, bit offsets are
+counted from high-order to low\dash order bits within a byte (or
+larger storage unit); in this case, the bit offset identifies
+the high\dash order bit of the object.}
+
+\item \textit{For little-endian architectures, bit offsets are
+counted from low\dash order to high\dash order bits within a byte (or
+larger storage unit); in this case, the bit offset identifies
+the low\dash order bit of the object.}
+\end{itemize}
+
+\textit{In either case, the bit so identified is defined as the 
+\addtoindexx{beginning of an object}
+beginning of the object.}
+
+\needlines{5}
+This section illustrates one possible representation of the 
+following \addtoindex{C} structure definition in both big- 
+and little-endian byte orders:
+
+\begin{lstlisting}
+struct S {
+    int j:5;
+    int k:6;
+    int m:5;
+    int n:8;
+};
+\end{lstlisting}
+
+Figures \ref{fig:bigendiandatabitoffsets} and
+\refersec{fig:littleendiandatabitoffsets}
+show the structure layout
+and data bit offsets for example big- and little-endian
+architectures, respectively. Both diagrams show a structure
+that begins at address A and whose size is four bytes. Also,
+high order bits are to the left and low order bits are to
+the right.
+
+\begin{figure}[h]
+\begin{dwflisting}
+\begin{verbatim}
+
+    j:0
+    k:5
+    m:11
+    n:16
+
+    Addresses increase ->
+    |       A       |     A + 1     |    A + 2      |    A + 3      | 
+
+    Data bit offsets increase ->
+    +---------------+---------------+---------------+---------------+
+    |0     4|5         10|11      15|16           23|24           31|
+    |   j   |     k      | m        |        n      |       <pad>   |
+    |       |            |          |               |               | 
+    +---------------------------------------------------------------+ 
+
+\end{verbatim}
+\end{dwflisting}
+\caption{Big-endian data bit offsets}
+\label{fig:bigendiandatabitoffsets}
+\end{figure}
+
+\begin{figure}[h]
+\begin{dwflisting}
+\begin{verbatim}
+
+    j:0
+    k:5
+    m:11
+    n:16
+                                               <- Addresses increase
+    |     A + 3     |     A + 2     |    A + 1      |       A       | 
+
+                                        <-  Data bit offsets increase 
+    +---------------+---------------+---------------+---------------+
+    |31           24|23           16|15     11|10       5|4        0|
+    |     <pad>     |        n      |    m    |    k     |     j    |
+    |               |               |         |          |          |
+    +---------------------------------------------------------------+
+
+\end{verbatim}
+\end{dwflisting}
+\caption{Little-endian data bit offsets}
+\label{fig:littleendiandatabitoffsets}
+\end{figure}
+
+\needlines{4}
+Note that data member bit offsets in this example are the
+same for both big\dash\ and little\dash endian architectures even
+though the fields are allocated in different directions
+(high\dash order to low-order versus low\dash order to high\dash order);
+the bit naming conventions for memory and/or registers of
+the target architecture may or may not make this seem natural.
+
 \clearpage
 \section{Namespace Examples}
 \label{app:namespaceexamples}
index 6d393c8..7dec9f4 100644 (file)
@@ -905,7 +905,8 @@ Each general operation represents a postfix operation on
 a simple stack machine. 
 Each element of the stack has a type and a value, and can represent
 a value of any supported base type of the target machine.  Instead of
-a base type, elements can have a special address type, 
+a base type, elements can have a 
+\livetarg{chap:specialaddresstype}{special address type},
 which is an integral type that has the 
 \addtoindex{size of an address} on the target machine and 
 unspecified signedness. The value on the top of the stack after 
@@ -945,10 +946,10 @@ The
 following operations all push a value onto the DWARF
 stack. 
 \addtoindexx{DWARF expression!stack operations}
-Operations other than \DWOPconsttype{} push a value with the special 
-address type, and if the value of a constant in one of these operations
-is larger than can be stored in a single stack element, the
-value is truncated to the element size and the low-order bits
+Operations other than \DWOPconsttype{} push a value with the 
+\specialaddresstype, and if the value of a constant in one of these 
+operations is larger than can be stored in a single stack element, 
+the value is truncated to the element size and the low-order bits
 are pushed on the stack.
 \begin{enumerate}[1. ]
 \itembfnl{\DWOPlitzeroTARG, \DWOPlitoneTARG, \dots, \DWOPlitthirtyoneTARG}
@@ -1029,7 +1030,7 @@ to a given signed offset.
 \DWOPregvaltype{} pushes the contents
 of the register together with the given base type, while the other operations
 push the result of adding the contents of a register to a given
-signed offset together with the special address type.
+signed offset together with the \specialaddresstype.
 
 \needlines{4}
 \begin{enumerate}[1. ]
@@ -1050,13 +1051,15 @@ a signed LEB128\addtoindexx{LEB128!signed} offset from
 the specified register.
 
 \itembfnl{\DWOPbregxTARG}
-The \DWOPbregxNAME{} operation has two operands: a register
+The \DWOPbregxNAME{} operation provides the sum of two values specified
+by its two operands. The first operand is a register number
 which is specified by an unsigned LEB128\addtoindexx{LEB128!unsigned}
-number, followed by a signed LEB128\addtoindexx{LEB128!signed} offset.
+number. The second operand is a signed LEB128\addtoindexx{LEB128!signed} offset.
 
 \needlines{8}
 \itembfnl{\DWOPregvaltypeTARG}
-The \DWOPregvaltypeNAME{} operation takes two operands. The first 
+The \DWOPregvaltypeNAME{} operation provides the contents of
+a given register interpreted as a value of a given type. The first 
 operand is an unsigned LEB128\addtoindexx{LEB128!unsigned} number, 
 which identifies a register whose contents is to
 be pushed onto the stack. The second operand is an 
@@ -1082,12 +1085,12 @@ consisting of the value together with its type identifier.
 The \DWOPderef{}, \DWOPderefsize{}, \DWOPxderef{}, \DWOPxderefsize{} 
 and \DWOPformtlsaddress{}
 operations require the popped values to have an integral type, either the
-special address type or some other integral base type, and push a 
-value with the special address type.  
+\specialaddresstype{} or some other integral base type, and push a 
+value with the \specialaddresstype.  
 \DWOPdereftype{} and \DWOPxdereftype{} operations have the
 same requirement on the popped values, but push a value together 
 with the same type as the popped values.
-All other operations push a value together with the special address type.
+All other operations push a value together with the \specialaddresstype.
 
 \begin{enumerate}[1. ]
 \itembfnl{\DWOPdupTARG}
@@ -1129,7 +1132,7 @@ becomes the second entry.
 The \DWOPderefNAME{} operation pops the top stack entry and 
 treats it as an address. The popped value must have an integral type.
 The value retrieved from that address is pushed, together with the
-special address type identifier. 
+\specialaddresstype{} identifier. 
 The size of the data retrieved from the 
 \addtoindexi{dereferenced}{address!dereference operator}
 address is the \addtoindex{size of an address} on the target machine.
@@ -1141,12 +1144,12 @@ The \DWOPderefsizeNAME{} operation behaves like the
 operation: it pops the top stack entry and treats it as an
 address. The popped value must have an integral type.
 The value retrieved from that address is pushed, together with the
-special address type identifier. In
+\specialaddresstype{} identifier. In
 the \DWOPderefsizeNAME{} operation, however, the size in bytes
 of the data retrieved from the dereferenced address is
 specified by the single operand. This operand is a 1-byte
 unsigned integral constant whose value may not be larger
-than the \addtoindex{size of an address} on the target machine. The data
+than the size of the \specialaddresstype. The data
 retrieved is zero extended to the size of an address on the
 target machine before being pushed onto the expression stack.
 
@@ -1176,11 +1179,10 @@ Both of these entries must have integral type identifiers.
 The top two stack elements are popped,
 and a data item is retrieved through an implementation-defined
 address calculation and pushed as the new stack top together with the
-special address type identifier.
+\specialaddresstype{} identifier.
 The size of the data retrieved from the 
 \addtoindexi{dereferenced}{address!dereference operator}
-address is the
-\addtoindex{size of an address} on the target machine.
+address is the size of the \specialaddresstype.
 
 \itembfnl{\DWOPxderefsizeTARG}
 The \DWOPxderefsizeNAME{} operation behaves like the
@@ -1202,7 +1204,7 @@ address is specified by the single operand. This operand is a
 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 together
-with the special address type identifier.
+with the \specialaddresstype{} identifier.
 
 \itembfnl{\DWOPxdereftypeTARG}
 The \DWOPxdereftypeNAME{} operation behaves like the \DWOPxderefsize{}
@@ -1243,12 +1245,12 @@ The \DWOPformtlsaddressNAME{}
 operation pops a value from the stack, which must have an 
 integral type identifier, translates this
 value into an address in the 
-\addtoindexx{thread-local storage}
-thread\dash local storage for a thread, and pushes the address 
-onto the stack together with the special address type identifier. 
+\addtoindex{thread-local storage}
+for a thread, and pushes the address 
+onto the stack together with the \specialaddresstype{} identifier. 
 The meaning of the value on the top of the stack prior to this 
 operation is defined by the run-time environment.  If the run-time 
-environment supports multiple thread\dash local storage 
+environment supports multiple thread-local storage 
 \nolink{blocks} for a single thread, then the \nolink{block} 
 corresponding to the executable or shared 
 library containing this DWARF expression is used.
@@ -1293,26 +1295,29 @@ is present, then it already encodes such changes, and it is
 space efficient to reference that.}
 \end{enumerate}
 
+\textit{Examples illustrating many of these stack operations are
+found in Appendix \refersec{app:dwarfstackoperationexamples}.}
+
 \subsubsection{Arithmetic and Logical Operations} 
 \addtoindexx{DWARF expression!arithmetic operations}
 \addtoindexx{DWARF expression!logical operations}
 The following provide arithmetic and logical operations.  If an operation
 pops two values from the stack, both values must have the same type,
-either the same base type or both the special address type.
+either the same base type or both the \specialaddresstype.
 The result of the operation which is pushed back has the same type
 as the type of the operands.  
 
-If the type of the operands is the special
-address type, except as otherwise specified, the arithmetic operations
+If the type of the operands is the \specialaddresstype, 
+except as otherwise specified, the arithmetic operations
 perform addressing arithmetic, that is, unsigned arithmetic that is performed
 modulo one plus the largest representable address (for example, 0x100000000
 when the \addtoindex{size of an address} is 32 bits). 
 
 Operations other than \DWOPabs{},
-\DWOPdiv{}, \DWOPminus{}, \DWOPmul{}, \DWOPneg{} and \DWOPplus{} require integral
-types of the operand (either integral base type or the special address
-type).  Operations do not cause an exception on overflow.
-
+\DWOPdiv{}, \DWOPminus{}, \DWOPmul{}, \DWOPneg{} and \DWOPplus{} 
+require integral types of the operand (either integral base type 
+or the \specialaddresstype).  Operations do not cause an exception 
+on overflow.
 
 \needlines{4}
 \begin{enumerate}[1. ]
@@ -1409,7 +1414,7 @@ following operations provide simple control of the flow of a DWARF expression.
 The six relational operators each:
 \begin{itemize}
 \item pop the top two stack values, which should both have the same type,
-either the same base type or both the special address type, 
+either the same base type or both the \specialaddresstype, 
 
 \item compare the operands:
 \linebreak
@@ -1418,10 +1423,10 @@ either the same base type or both the special address type,
 \item push the constant value 1 onto the stack 
 if the result of the operation is true or the
 constant value 0 if the result of the operation is false.
-The pushed value has the special address type.
+The pushed value has the \specialaddresstype.
 \end{itemize}
 
-If the operands have the special address type, the comparisons  
+If the operands have the \specialaddresstype, the comparisons  
 are performed as signed operations.
 The six operators are \DWOPleNAME{} (less than or equal to), \DWOPgeNAME{}
 (greater than or equal to), \DWOPeqNAME{} (equal to), \DWOPltNAME{} (less
@@ -1504,7 +1509,7 @@ The \DWOPconvertNAME{} operation pops the top stack entry, converts it to a
 different type, then pushes the result. It takes one operand, which is an
 unsigned LEB128 integer that represents the offset of a debugging
 information entry in the current compilation unit, or value 0 which
-represents the special address type. If the operand is non-zero, the
+represents the \specialaddresstype. If the operand is non-zero, the
 referenced entry must be a \DWTAGbasetype{} entry that provides the type
 to which the value is converted.
 
@@ -1513,18 +1518,11 @@ The \DWOPreinterpretNAME{} operation pops the top stack entry, reinterprets
 the bits in its value as a value of a different type, then pushes the
 result. It takes one operand, which is an unsigned LEB128 integer that
 represents the offset of a debugging information entry in the current
-compilation unit, or value 0 which represents the special address type.
+compilation unit, or value 0 which represents the \specialaddresstype.
 If the operand is non-zero, the referenced entry must be a
 \DWTAGbasetype{} entry that provides the type to which the value is converted.
 The type of the operand and result type should have the same size in bits.
 
-\textit{The semantics of the reinterpretation of a value is as if in 
-\addtoindex{C} or \addtoindex{C++}
-there are two variables, one with the type of the operand, into which
-the popped value is stored, then copied using \texttt{memcpy} into the other variable
-with the type of the result and the pushed result value is the value of the
-other variable after \texttt{memcpy}.}
-
 \end{enumerate}
 
 \needlines{7}
@@ -1542,8 +1540,9 @@ on the location stack or any of its values.
 The \DWOPentryvalueTARG{} operation pushes a value that had a known location
 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 operand specifies the length
+a block containing a DWARF expression or a register location description 
+(see Section \refersec{chap:registerlocationdescriptions}).  
+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,
@@ -1558,67 +1557,21 @@ being pushed by the \DWOPentryvalueNAME{} operation.
 \textit{The \DWOPentryvalueNAME{} operation can be used by consumers if they are able
 to find the call site in the caller function, can unwind to it, and the corresponding
 \DWTAGcallsiteparameter{} entry has \DWATcallvalue{} or
-\DWATcalldatavalue{} attributes that can be evaluated to find out the
+\DWATcalldatavalue{} attributes that can be evaluated to find the
 value a function parameter had on the first instruction in the function.
 Non-interactive consumers which know what variables will need to be
-inspected ahead of running the debugged program could put breakpoints
-on the first instruction in functions where there is no other way to find(see 
-some variable's value, other than evaluating the \DWOPentryvalueNAME{} 
+inspected in advance of running the debugged program could put breakpoints
+on the first instruction in functions where there is no way to find
+some variable's value other than by evaluating the \DWOPentryvalueNAME{} 
 operation.  The consumer can collect the value of registers or 
 memory referenced in
 \DWOPentryvalueNAME{} operations, then continue to breakpoints where the values
-of variables or parameters need to be inspected and there use the remembered
-register or memory values during \DWOPentryvalueNAME{} evaluation.
-}
+of variables or parameters need to be inspected and use the remembered
+register or memory values during \DWOPentryvalueNAME{} evaluation.}
 
 \end{enumerate}
 
-\subsection{Example Stack Operations}
-\textit {The 
-\addtoindexx{DWARF expression!examples}
-stack operations defined in 
-Section \refersec{chap:stackoperations}.
-are fairly conventional, but the following
-examples illustrate their behavior graphically.}
-
-\begin{longtable}[c]{rrcrr} 
-\multicolumn{2}{c}{Before} & Operation & \multicolumn{2}{c}{After} \\
-\hline
-\endhead
-\endfoot
-0& 17& \DWOPdup{} &0 &17 \\*
-1&   29& &  1 & 17 \\*
-2& 1000 & & 2 & 29\\*
-& & &         3&1000\\
-
-& & & & \\
-0 & 17 & \DWOPdrop{} & 0 & 29 \\*
-1 &29  &            & 1 & 1000 \\*
-2 &1000& & &          \\
-
-& & & & \\
-0 & 17 & \DWOPpick, 2 & 0 & 1000 \\*
-1 & 29 & & 1&17 \\*
-2 &1000& &2&29 \\*
-  &    & &3&1000 \\
-
-& & & & \\
-0&17& \DWOPover&0&29 \\*
-1&29& &  1&17 \\*
-2&1000 & & 2&29\\*
- &     & & 3&1000 \\
-
-& & & & \\
-0&17& \DWOPswap{} &0&29 \\*
-1&29& &  1&17 \\*
-2&1000 & & 2&1000 \\
-
-& & & & \\
-0&17&\DWOProt{} & 0 &29 \\*
-1&29 & & 1 & 1000 \\*
-2& 1000 & &  2 & 17 \\
-\end{longtable}
-
+\needlines{5}
 \section{Location Descriptions}
 \label{chap:locationdescriptions}
 \textit{Debugging information 
@@ -1695,7 +1648,7 @@ separate
 \addtoindexx{location list}
 location list table).
 
-
+\needlines{8}
 \subsection{Single Location Descriptions}
 A single location description is either:
 \begin{enumerate}[1. ]
@@ -1941,91 +1894,6 @@ the piece to be assembled into a value or assigned to is not
 byte-sized or is not at the start of a register or addressable
 unit of memory.}
 
-
-
-
-\subsubsection{Example Single Location Descriptions}
-
-Here are some examples of how DWARF operations are used to form location descriptions:
-% Probably the only place that this will be used, so not in dwarf.tex?
-\newcommand{\descriptionitemnl}[1]{\item[#1]\mbox{}\\}
-\begin{description}
-\descriptionitemnl{\DWOPregthree}
-The value is in register 3.
-
-\descriptionitemnl{\DWOPregx{} 54}
-The value is in register 54.
-
-\descriptionitemnl{\DWOPaddr{} 0x80d0045c}
-The value of a static variable is at machine address 0x80d0045c.
-
-\descriptionitemnl{\DWOPbregeleven{} 44}
-Add 44 to the value in register 11 to get the address of an automatic
-variable instance.
-
-\needlines{4}
-\descriptionitemnl{\DWOPfbreg{} -50}
-Given a \DWATframebase{} value of
-\doublequote{\DWOPbregthirtyone{} 64,} this example
-computes the address of a local variable that is -50 bytes from a
-logical frame pointer that is computed by adding 64 to the current
-stack pointer (register 31).
-
-\descriptionitemnl{\DWOPbregx{} 54 32 \DWOPderef}
-A call-by-reference parameter whose address is in the word 32 bytes
-from where register 54 points.
-
-\needlines{4}
-\descriptionitemnl{\DWOPplusuconst{} 4}
-A structure member is four bytes from the start of the structure
-instance. The base address is assumed to be already on the stack.
-
-\descriptionitemnl{\DWOPregthree{} \DWOPpiece{} 4 \DWOPregten{} \DWOPpiece{} 2}
-A variable whose first four bytes reside in register 3 and whose next
-two bytes reside in register 10.
-
-\descriptionitemnl{\DWOPregzero{} \DWOPpiece{} 4 \DWOPpiece{} 4 \DWOPfbreg{} -12 \DWOPpiece{} 4}
-\vspace{-2\parsep}A twelve byte value whose first four bytes reside in register zero,
-whose middle four bytes are unavailable (perhaps due to optimization),
-and whose last four bytes are in memory, 12 bytes before the frame
-base.
-
-\descriptionitemnl{\DWOPbregone{} 0 \DWOPbregtwo{} 0 \DWOPplus{} \DWOPstackvalue{} }
-Add the contents of r1 and r2 to compute a value. This value is the
-\doublequote{contents} of an otherwise anonymous location.
-
-\needlines{4}
-\descriptionitemnl{\DWOPlitone{} \DWOPstackvalue{} \DWOPpiece{} 4 \DWOPbregthree{} 0 \DWOPbregfour{} 0}
-\vspace{-2\parsep}\descriptionitemnl{
-\hspace{0.5cm}\DWOPplus{} \DWOPstackvalue{} \DWOPpiece{} 4 \DWOPpiece{} 4}
-The object value is found in an anonymous (virtual) location whose
-value consists of two parts, given in memory address order: the 4 byte
-value 1 followed by the four byte value computed from the sum of the
-contents of r3 and r4.
-
-\descriptionitemnl{\DWOPentryvalue{} 1 \DWOPregone{} \DWOPstackvalue }
-The value register 1 had upon entering the current subprogram.
-
-\descriptionitemnl{\DWOPentryvalue{} 2 \DWOPbregone{} 0 \DWOPstackvalue }
-The value register 1 had upon entering the current subprogram (same as the previous example).
-%Both of these location descriptions evaluate to the value register 1 had upon
-%entering the current subprogram.
-
-%FIXME: The following gets an undefined control sequence error for reasons unknown... 
-%\descriptionitemnl{\DWOPentryvalue{} 1 \DWOPregthirtyone{} \DWOPregone{} \DWOPadd{} \DWOPstackvalue }
-%The value register 31 had upon entering the current subprogram
-%plus the value register 1 currently has.
-
-\descriptionitemnl{\DWOPentryvalue{} 3 \DWOPbregfour{} 16 \DWOPderef{} \DWOPstackvalue }
-%FIXME: similar undefined as just above
-%\descriptionitemnl{\DWOPentryvalue{} 6 \DWOPentryvalue{} 1 \DWOPregfour{} \DWOPplusuconst{} 16 \DWOPderef{} \DWOPstackvalue }
-%These two location expressions do the same thing, p
-Add 16 to the value register 4 had upon entering the current subprogram
-to form an address and then push the value of the memory location at that address.
-
-\end{description}
-
-
 \subsection{Location Lists}
 \label{chap:locationlists}
 There are two forms of location lists. The first form 
@@ -2051,6 +1919,19 @@ attribute whose value is an offset from the beginning of
 the \dotdebugloc{} section to the first byte of the list for the
 object in question.
 
+The \addtoindex{applicable base address} of a normal
+location list entry (see following) is
+\addtoindexx{location list!base address selection entry}
+determined by the closest preceding base address selection
+entry in the same location list. If there is
+no such selection entry, then the applicable base address
+defaults to the base address of the compilation unit (see
+Section \refersec{chap:normalandpartialcompilationunitentries}).  
+
+\textit{In the case of a compilation unit where all of
+the machine code is contained in a single contiguous section,
+no base address selection entry is needed.}
+
 Each entry in a location list is either a location 
 \addtoindexi{list}{address selection|see{base address selection}} 
 entry,
@@ -2062,12 +1943,14 @@ or an
 \addtoindexx{end-of-list entry!in location list}
 end-of-list entry.
 
+\subsubsubsection{Location List Entry}
 A location list entry has two forms:
 a normal location list entry and a default location list entry.
 
 \needlines{4}
-A \addtoindexx{location list!normal entry}
-normal location list entry consists of:
+\subsubsubsubsection{Normal Location List Entry}
+A\addtoindexx{location list!normal entry}
+\addtoindex{normal location list entry} consists of:
 \begin{enumerate}[1. ]
 \item A beginning address offset. 
 This address offset has the \addtoindex{size of an address} and is
@@ -2098,20 +1981,6 @@ describing the location of the object over the range specified by
 the beginning and end addresses.
 \end{enumerate}
 
-\needlines{5}
-The applicable base address of a normal
-location list entry is
-\addtoindexx{location list!base address selection entry}
-determined by the closest preceding base address selection
-entry (see below) in the same location list. If there is
-no such selection entry, then the applicable base address
-defaults to the base address of the compilation unit (see
-Section \refersec{chap:normalandpartialcompilationunitentries}).  
-
-\textit{In the case of a compilation unit where all of
-the machine code is contained in a single contiguous section,
-no base address selection entry is needed.}
-
 Address ranges defined by normal location list entries
 may overlap. When they do, they describe a
 situation in which an object exists simultaneously in more than
@@ -2121,7 +1990,8 @@ object in question is defined, it is assumed that the object is
 not available for the portion of the range that is not covered.
 
 \needlines{4}
-A default location list entry consists of:
+\subsubsubsubsection{Default Location List Entry}
+A \addtoindex{default location list entry} consists of:
 \addtoindexx{location list!default entry}
 \begin{enumerate}[1. ]
 \item The value 0.
@@ -2140,13 +2010,12 @@ A default location list entry must be the last location list
 entry of a location list except for the terminating end-of-list
 entry.
 
-A default location list entry describes an unlimited number
-(zero, one or more) of address ranges, none of which overlap
-any of the address ranges defined earlier in the same location
-list. Further, all such address ranges have the same simple
-location.
+A \addtoindex{default location list entry} describes a simple 
+location which applies to all addresses which are not included 
+in any range defined earlier in the same location list.
 
 \needlines{5}
+\subsubsubsection{Base Address Selection Entry}
 A base 
 \addtoindexi{address}{address selection|see{base address selection}}
 \addtoindexx{location list!base address selection entry}
@@ -2163,9 +2032,10 @@ and ending address offsets of subsequent entries of the location list.
 \end{enumerate}
 
 \textit{A base address selection entry 
-affects only the list in which it is contained.}
+affects only the remainder of the list in which it is contained.}
 
 \needlines{5}
+\subsubsubsection{End-of-List Entry}
 The end of any given location list is marked by an 
 \addtoindexx{location list!end-of-list entry}
 end-of-list entry, which consists of a 0 for the beginning address
@@ -2199,13 +2069,23 @@ selection entry and end-of-list entry, respectively, for a
 (see Section \refersec{chap:noncontiguousaddressranges}) 
 in interpretation and representation.}
 
+\needlines{5}
 \subsubsection{Location Lists in Split Objects}
 \label{chap:locationlistsinsplitobjects}
 In a split DWARF object (see 
 Section \refersec{datarep:splitdwarfobjects}), 
 location lists are contained in the \dotdebuglocdwo{} section.
 
-Each entry in the location list
+The \addtoindex{applicable base address} of a split
+location list entry (see following) is
+\addtoindexx{location list!base address selection entry}
+determined by the closest preceding base address selection
+entry (\DWLLEbaseaddressselectionentry) in the same location list. If there is
+no such selection entry, then the applicable base address
+defaults to the base address of the compilation unit (see
+Section \refersec{chap:normalandpartialcompilationunitentries}).
+
+Each entry in the split location list
 begins with a type code, which is a single unsigned byte that
 identifies the type of entry. There are five types of entries:
 \begin{enumerate}
@@ -2229,7 +2109,8 @@ This entry contains two unsigned LEB128\addtoindexx{LEB128!unsigned}
 values immediately following the type code. These values are the
 indices of two addresses in the \dotdebugaddr{} section.
 These indices are relative to the value of the 
-\DWATaddrbase{} attribute of the associated compilation unit.
+\DWATaddrbase{} attribute of the associated compilation unit
+(see Section \refersec{chap:unitentries}).
 These indicate the starting and ending addresses,
 respectively, that define the address range for which
 this location is valid. The starting and ending addresses
@@ -2261,6 +2142,14 @@ range for which this location is valid. A single location
 description follows the fields that define the address range.
 \end{enumerate}
 
+\textit{The \DWLLEbaseaddressselectionentry, \DWLLEstartendentry{}
+and \DWLLEstartlengthentry entries obtain addresses within the 
+target program indirectly using an index (not an offset) into an 
+array of addresses. The base of that array is obtained using the 
+\DWATaddrbase{} attribute of the containing compilation unit. 
+The value of that attribute is the offset of the base of the array 
+in the \dotdebugaddr{} section of the unit.}
+
 \needlines{10}
 \section{Types of Program Entities}
 \label{chap:typesofprogramentities}
@@ -2400,7 +2289,7 @@ of the item being described. If the entry containing the
 \DWAThighpc,
 \DWATranges{} or 
 \DWATentrypc{} attribute, 
-\addtoindexx{entry pc attribute}
+\addtoindexx{entry PC attribute}
 or 
 a location
 description that evaluates to an address, then those address
@@ -2492,8 +2381,10 @@ void myfunc()
 
 
 \textit{\addtoindex{C} scoping rules require that the 
-value of the variable x passed to the function g is the value of the
-global variable x rather than of the local version.}
+value of the variable \texttt{x} passed to the function 
+\texttt{g} is the value of the global \texttt{float} 
+variable \texttt{x} rather than of the local \texttt{int} 
+variable \texttt{x}.}
 
 \subsection{Non-Defining Declarations}
 A debugging information entry that 
@@ -2535,19 +2426,16 @@ attribute whose value is the type signature
 Not all attributes of the debugging information entry referenced by a
 \DWATspecification{} attribute 
 apply to the referring debugging information entry.
-
-\textit{For 
-\addtoindexx{declaration attribute}
+For\addtoindexx{declaration attribute}
 example,
 \DWATsibling{} and 
 \DWATdeclaration{} 
 \addtoindexx{declaration attribute}
-clearly cannot apply to a 
+cannot apply to a 
 \addtoindexx{declaration attribute}
 referring
 \addtoindexx{sibling attribute}
-entry.}
-
+entry.
 
 
 \section{Declaration Coordinates}
@@ -2761,7 +2649,7 @@ and exists totally within the boundaries specified by those
 two attributes. If that is not the case, no low and high PC
 attributes should be produced.
 
-\subsection{Non\dash Contiguous Address Ranges}
+\subsection{Non-Contiguous Address Ranges}
 \label{chap:noncontiguousaddressranges}
 When the set of addresses of a debugging information entry
 \addtoindexx{non-contiguous address ranges}
@@ -2798,30 +2686,44 @@ object language relocations needed for references to the \dotdebugranges{}
 section from one for each range entry to a single relocation that
 applies for the entire compilation unit.}
 
+The \addtoindex{applicable base address} of a \addtoindex{range list} 
+entry is determined
+by the closest preceding base address selection entry (see
+below) in the same range list. If there is no such selection
+entry, then the applicable base address defaults to the base
+address of the compilation unit 
+(see Section \refersec{chap:normalandpartialcompilationunitentries}).
+
+\textit{In the case of a compilation unit where all of the machine
+code is contained in a single contiguous section, no base
+address selection entry is needed.}
+
+Address range entries in a \addtoindex{range list} may not overlap.
+There is no requirement that the entries be ordered in any particular way.
+
 Each entry in a \addtoindex{range list} is either a 
-\addtoindex{range list} entry,
+\addtoindex{range list entry},
 \addtoindexx{base address selection entry!in range list}
 a base address selection entry, or an 
 \addtoindexx{end-of-list entry!in range list}
 end-of-list entry.
 
-A \addtoindex{range list} entry consists of:
+\needlines{5}
+\subsubsection{Range List Entry}
+A \addtoindex{range list entry} consists of:
 \begin{enumerate}[1. ]
 \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 
+the \addtoindex{applicable base address} of the compilation unit referencing this 
 \addtoindex{range list}. 
-It marks the
-beginning of an 
-\addtoindexi{address}{address range!in range list} 
-range.
+It marks the beginning of an 
+\addtoindexi{address range}{address range!in range list}. 
 
 \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 
+to the \addtoindex{applicable base address} of the compilation unit referencing 
 this \addtoindex{range list}.
-It marks the
-first address past the end of the address range.
+It marks the first address past the end of the address range.
 The ending address must be greater than or
 equal to the beginning address.
 
@@ -2832,36 +2734,22 @@ ending addresses are equal has no effect because the size of the
 range covered by such an entry is zero.}
 \end{enumerate}
 
-The applicable base address of a \addtoindex{range list} entry
-is determined
-by the closest preceding base address selection entry (see
-below) in the same range list. If there is no such selection
-entry, then the applicable base address defaults to the base
-address of the compilation unit 
-(see Section \refersec{chap:normalandpartialcompilationunitentries}).
-
-\textit{In the case of a compilation unit where all of the machine
-code is contained in a single contiguous section, no base
-address selection entry is needed.}
-
-Address range entries in
-a \addtoindex{range list} may not overlap.
-There is no requirement that
-the entries be ordered in any particular way.
-
 \needlines{5}
-A base address selection entry consists of:
+\subsubsection{Base Address Selection Entry}
+A \addtoindex{base address selection entry} consists of:
 \begin{enumerate}[1. ]
-\item The value of the largest representable address offset (for example, \wffffffff when the size of
-an address is 32 bits).
+\item The value of the largest representable address offset 
+(for example, \wffffffff when the size of an address is 32 bits).
 
-\item An address, which defines the appropriate base address for use in interpreting the beginning
-and ending address offsets of subsequent entries of the location list.
+\item An address, which defines the appropriate base address 
+for use in interpreting the beginning and ending address offsets 
+of subsequent entries of the location list.
 \end{enumerate}
-\textit{A base address selection entry 
-affects only the list in which it is contained.}
 
+\textit{A base address selection entry affects only the 
+remainder of list in which it is contained.}
 
+\subsubsection{End-of-List Entry}
 The end of any given \addtoindex{range list} is marked by an 
 \addtoindexx{end-of-list entry!in range list}
 end-of-list entry, 
@@ -2881,7 +2769,6 @@ and end-of-list entry, respectively, for a location list
 in interpretation and representation.}
 
 
-
 \section{Entry Address}
 \label{chap:entryaddress}
 \textit{The entry or first executable instruction generated
@@ -2894,13 +2781,14 @@ a range of code addresses, which includes compilation units,
 module initialization, subroutines, 
 \livelink{chap:lexicalblock}{lexical \nolink{blocks}},
 \livelink{chap:tryandcatchblockentries}{try/catch \nolink{blocks}},
-and the like, may have a \DWATentrypcNAME{} attribute to
-indicate the first executable instruction within that 
+and the like, may have a \DWATentrypcNAME{} attribute 
+\addtoindexx{entry PC address}
+to indicate the first executable instruction within that 
 range\hypertarget{chap:entryaddressofscope}{}
 of addresses. The value of the \DWATentrypcNAME{} attribute is a
 relocated address if the
-value of \DWATentrypcNAME{} is of class address; or if it is of class
-constant, the value is an unsigned integer offset which, when
+value of \DWATentrypcNAME{} is of class \CLASSaddress; or if it is of class
+\CLASSconstant, the value is an unsigned integer offset which, when
 added to the base address of the function, gives the entry
 address. 
 
@@ -2909,8 +2797,8 @@ The base address of the containing scope is given by either the
 ranges given by the \DWATranges{} attribute. 
 If no \DWATentrypcNAME{} attribute is present,
 then the entry address is assumed to be the same as the
-value of the \DWATlowpc{} attribute, if present; otherwise,
-the entry address is unknown.
+base address.
+
 
 \section{Static and Dynamic Values of Attributes}
 \label{chap:staticanddynamicvaluesofattributes}
@@ -2943,25 +2831,10 @@ evaluation of the expression yields the value of
 the attribute.
 \end{itemize}
 
-\textit{%
-Whether an attribute value can be dynamic depends on the
+\textit{Whether an attribute value can be dynamic depends on the
 rules of the applicable programming language.
 }
 
-\textit{The applicable attributes include: 
-\DWATallocated,
-\DWATassociated, 
-%\DWATbitoffset, 
-\DWATbitsize,
-\DWATbitstride,
-\DWATbytesize,
-\DWATbytestride, 
-\DWATcount, 
-\DWATlowerbound,
-\DWATrank,
-\DWATupperbound,
-and possibly others.}
-
 \needlines{4}
 \section{Entity Descriptions}
 \textit{Some debugging information entries may describe entities
@@ -2969,13 +2842,12 @@ in the program that are artificial, or which otherwise have a
 \doublequote{name} that is not a valid identifier in the
 programming language. For example, several languages may
 capture or freeze the value of a variable at a particular
-point in the program. 
+point in the program and hold that value in an artificial variable
 \addtoindex{Ada} 95 has package elaboration routines,
 type descriptions of the form \texttt{typename\textquoteright Class}, and 
-\doublequote{access typename} parameters.  }
+\doublequote{\texttt{access} typename} parameters.}
 
-Generally, any debugging information
-entry that 
+Generally, any debugging information entry that 
 \hypertarget{chap:DWATdescriptionartificialnameordescription}{}
 has, or may have, 
 \addtoindexx{name attribute}
@@ -2987,11 +2859,8 @@ a
 \DWATdescription{} attribute whose value is a
 null-terminated string providing a description of the entity.
 
-
 \textit{It is expected that a debugger will only display these
-descriptions as part of the description of other entities. It
-should not accept them in expressions, nor allow them to be
-assigned, or the like.}
+descriptions as part of the description of other entities.}
 
 \needlines{4}
 \section{Byte and Bit Sizes}
 attribute whose value is a null-terminated string containing the 
 object file linkage name associated with the corresponding entity.
 
-% Some trouble here with hbox full, so we try optional word breaks.
-\textit{Debugging information entries to which \DWATlinkagename{}
-may apply include: \DWTAGcommonblock, \DWTAGconstant,
-\DWTAGentrypoint, \DWTAGsubprogram{} 
-and \DWTAGvariable.
-}
 
 \section{Template Parameters}
 \label{chap:templateparameters}
-\textit{In \addtoindex{C++}, a template is a generic definition of a class, function, member
-function, or typedef (alias).  A template has formal parameters that
+\textit{In \addtoindex{C++}, a template is a generic definition 
+of a class, function, member function, or typedef (alias).  
+A template has formal parameters that
 can be types or constant values; the class, function,
 member function, or typedef is instantiated differently for each
 distinct combination of type or value actual parameters.  DWARF does
 not represent the generic template definition, but does represent each
-instantiation.
-}
+instantiation.}
 
 A debugging information entry that represents a 
 \addtoindex{template instantiation}
@@ -3108,10 +2971,9 @@ actual compile-time or run-time constant value
 of the value parameter for this instantiation.
 This can be a 
 \DWATconstvalue{}\livetarg{chap:DWATconstvaluetemplatevalueparameter}{} 
-attribute, whose
-value is the compile-time constant value as represented 
-on the target architecture. 
-Or, the attribute can be a \DWATlocation{} attribute, whose value is a 
+attribute, whose value is the compile-time constant value 
+as represented on the target architecture, or a 
+\DWATlocation{} attribute, whose value is a 
 single location description for the run-time constant address.
 
 \section{Alignment}
@@ -3127,17 +2989,6 @@ This constant describes the actual alignment used by the compiler.
 user specified an alignment the compiler could not satisfy, then 
 only the strictest alignment is added using this attribute.)
 
-\textit{Debugging information entries to which \DWATalignment{} may 
-apply include (but are not limited to):
-\DWTAGarraytype, \DWTAGatomictype, \DWTAGbasetype, 
-\DWTAGclasstype, 
-\DWTAGcoarraytype, \DWTAGconsttype, \DWTAGdynamictype,
-\DWTAGenumerationtype, \DWTAGfiletype, \DWTAGinterfacetype,
-\DWTAGpackedtype, \DWTAGpointertype, \DWTAGptrtomembertype,
-\DWTAGreferencetype, \DWTAGrestricttype, \DWTAGrvaluereferencetype,
-\DWTAGsettype, \DWTAGsharedtype, \DWTAGstringtype, \DWTAGstructuretype,
-\DWTAGsubprogram, \DWTAGsubrangetype, \DWTAGsubroutinetype,
-\DWTAGthrowntype, \DWTAGtypedef, \DWTAGuniontype, and \DWTAGvariable.}
-
-
-
+\textit{For example, an alignment attribute whose value is 8 indicates
+that the entity to which it applies occurs at an address that is a
+multiple of eight (not a multiple of $2^8$ or 256).}
\ No newline at end of file
index 5968ac4..a96aecd 100644 (file)
@@ -91,7 +91,7 @@ of the formal definition.
 \section{Vendor Extensibility}
 
 This document does not attempt to cover all interesting
-languages or even to cover all of the interesting debugging
+languages or even to cover all of the possible debugging
 information needs for its primary target languages. 
 Therefore,
 the document provides vendors a way to define their own
index 6cb303e..28d7c84 100644 (file)
@@ -46,7 +46,7 @@ would require a search of all the top level type definitions
 of all compilation units in a program.}
 
 \textit{To find the debugging information associated with a subroutine,
-given an address, a debugger can use the low and high pc
+given an address, a debugger can use the low and high PC
 attributes of the compilation unit entries to quickly narrow
 down the search, but these attributes only cover the range
 of addresses for the text associated with a compilation unit
index a8bc3e0..4e8d350 100644 (file)
@@ -8,6 +8,7 @@ these entries may be thought of
 as bounded by ranges of text addresses within the program.
 
 \section{Unit Entries}
+\label{chap:unitentries}
 An object file may contain one or more compilation units,
 of which there are
 \addtoindexx{unit|see {compilation unit}} 
@@ -63,7 +64,7 @@ used to represent portions of an object file.
 \textit{A normal compilation unit typically represents the text and
 data contributed to an executable by a single relocatable
 object file. It may be derived from several source files,
-including pre\dash processed \doublequote{include files.} 
+including pre-processed header files. 
 A \addtoindex{partial compilation unit} typically represents a part of the text
 and data of a relocatable object file, in a manner that can
 potentially be shared with the results of other compilations
@@ -316,13 +317,13 @@ entries used by entries in the current compilation unit
 (see Section \refersec{chap:basetypeentries}).
 
 \needlines{6}
-This attribute provides a consumer a way to find the definition
+\textit{This attribute provides a consumer a way to find the definition
 of base types for a compilation unit that does not itself
 contain such definitions. This allows a consumer, for example,
 to interpret a type conversion to a base type 
 % getting this link target at the right spot is tricky.
 \hypertarget{chap:DWATuseUTF8compilationunitusesutf8strings}{}
-correctly.
+correctly.}
 
 \item A \DWATuseUTFeight{} attribute,
 \addtoindexx{use UTF8 attribute}\addtoindexx{UTF-8} 
@@ -360,6 +361,7 @@ Section \refersec{chap:generalsubroutineandentrypointinformation}).}
 executable instruction of the unit (see 
 Section \refersec{chap:entryaddress}).
 
+\needlines{8}
 \item A \DWATstroffsetsbaseNAME\addtoindexx{string offset base attribute}
 \hypertarget{chap:DWATstroffsetbaseforindirectstringtable}{} 
 attribute, whose value is a reference. 
@@ -406,10 +408,11 @@ of that compilation unit is not valid.
 When generating a split DWARF object (see 
 Section \refersec{datarep:splitdwarfobjects}), the
 compilation unit in the \dotdebuginfo{} section is a "skeleton"
-compilation unit, which contains only a subset of the
+compilation unit, which contains \DWATdwoname{} and \DWATdwoid{}
+attributes as well as a subset of the
 attributes of a full normal or partial compilation unit. In general, 
 it contains those attributes that are necessary for the consumer
-to locate the DWARF object where the full compilation unit
+to locate the object file where the full compilation unit
 can be found, and for the consumer to interpret references to
 addresses in the program. 
 
@@ -435,7 +438,7 @@ compilation unit entries).
 \livetarg{chap:DWATdwonameforunit}{}
 A \DWATdwonameNAME{} attribute whose value is a
 null-terminated string containing the full or relative
-path name of the DWARF object file that contains the full
+path name of the object file that contains the full
 compilation unit.
 
 \item
@@ -453,9 +456,9 @@ entries).
 \textit{This attribute applies to strings referred to by the skeleton
 compilation unit entry itself, and strings in the associated line
 number information.
-The representation for strings in the DWARF object file is determined
-by the presence of a \DWATuseUTFeight{} attribute in the full compilation
-unit.}
+The representation for strings in the object file referenced 
+by the \DWATdwoname{} attribute is determined by the presence 
+of a \DWATuseUTFeight{} attribute in the full compilation unit.}
 
 \item
 A \DWATstroffsetsbase{} attribute, for indirect strings references 
@@ -474,13 +477,12 @@ compilation unit entries).
 
 All other attributes of a compilation unit entry (described
 in Section \refersec{chap:normalandpartialcompilationunitentries}) 
-should be placed in the full compilation
-unit entry in the \dotdebuginfodwo{} section of the split DWARF
-object. The attributes provided by the skeleton compilation
+should be placed in the full compilation unit.
+The attributes provided by the skeleton compilation
 unit entry do not need to be repeated in the full compilation
 unit entry, except for \DWATdwoid, which should appear in
 both entries so that the consumer can verify that it has
-found the correct DWARF object.
+found the correct object file.
 
 \needlines{6}
 \subsection{Type Unit Entries}
@@ -514,6 +516,7 @@ constant value is an integer code indicating the source
 language used to define the type. The set of language names
 and their meanings are given in Table \refersec{tab:languagenames}.
 
+\needlines{4}
 \item A 
 \DWATstroffsetsbase\addtoindexx{string base offset attribute}
 attribute, whose value is a reference. This attribute points
@@ -522,9 +525,10 @@ the \dotdebugstroffsets{} section. Indirect string references
 (using \DWFORMstrx) within the type unit must be interpreted
 as indices relative to this base.
 
-\item A \DWATstmtlist{} attribute, whose
-value is a section offset to a line number table for this
-type unit. Because type units do not describe any code, they
+\item A \DWATstmtlist{} attribute\addtoindexx{statement list attribute}
+whose value of class \CLASSlineptr{} points to the line number 
+information for this type unit.
+Because type units do not describe any code, they
 do not actually need a line number table, but the line number
 tables also contain a list of directories and file names that
 may be referenced by the \DWATdeclfile{} attribute. In a
@@ -567,6 +571,7 @@ U is a direct child of the type unit entry. The containing
 entries may be shared among the additional types and between
 T and the additional types.
 
+\needlines{4}
 \textit{Types are not required to be placed in type units. In general,
 only large types such as structure, class, enumeration, and
 union types included from header files should be considered
@@ -626,7 +631,7 @@ the module initialization code
 (see Section \refersec{chap:codeaddressesandranges}). 
 \hypertarget{chap:DWATentrypcentryaddressofmoduleinitialization}{}
 It may also
-\addtoindexx{entry pc attribute!for module initialization}
+\addtoindexx{entry PC attribute!for module initialization}
 have a 
 \DWATentrypc{} attribute whose value is the address of
 the first executable instruction of that initialization code
@@ -792,7 +797,7 @@ An imported declaration may also have a
 \DWATname{}
 attribute
 \addtoindexx{name attribute}
-whose value is a null\dash terminated string containing the
+whose value is a null-terminated string containing the
 name, as it appears in the source program, by which the
 imported entity is to be known in the context of the imported
 declaration entry (which may be different than the name of
@@ -1032,13 +1037,7 @@ and provide a user\dash supplied name for the main subroutine of
 a program.
 }
 
-\textit{A common debugger feature is to allow the debugger user to call
-a subroutine within the subject program. In certain cases,
-however, the generated code for a subroutine will not obey
-the standard calling conventions for the target architecture
-and will therefore not be safe to call from within a debugger.
-}
-
+\subsubsection{Calling Convention Information}
 A subroutine entry may 
 \hypertarget{chap:DWATcallingconventionforsubprograms}{}
 contain a 
@@ -1076,19 +1075,25 @@ then the debugging information entry for such a subroutine
 may have a calling convention attribute whose value is the
 constant \DWCCprogramTARG.
 
+\textit{A common debugger feature is to allow the debugger user to call
+a subroutine within the subject program. In certain cases,
+however, the generated code for a subroutine will not obey
+the standard calling conventions for the target architecture
+and will therefore not be safe to call from within a debugger.}
+
 \textit{The \DWCCprogram{} 
 value is intended to support \addtoindex{Fortran} main
 \addtoindexx{Fortran!main program}
 programs which in some implementations may not be callable
 or which must be invoked in a special way. It is not intended
-as a way of finding the entry address for the program.
-}
+as a way of finding the entry address for the program.}
+
 
+\subsubsection{Miscellaneous Subprogram Properties}
 \textit{In \addtoindex{C}
 there is a difference between the types of functions
 declared using function prototype style declarations and
-those declared using non\dash prototype declarations.
-}
+those declared using non\dash prototype declarations.}
 
 A subroutine entry declared with a function prototype style
 declaration may have 
@@ -1146,11 +1151,19 @@ indicates whether the subprogram was declared with the \doublequote{noreturn} ke
 indicating that the subprogram can be called, but will never return to its caller.
 
 \subsubsection{Call Site-Related Attributes}
+\textit{While subprogram attributes in the pervious section provide
+information about the subprogram and it's entry point(s) as a whole,
+the following attributes provide summary information about the calls
+that occur within a subprogram.}
+
 A subroutine entry may have \DWATcallalltailcalls, \DWATcallallcalls{} 
 and/or \DWATcallallsourcecalls{} attributes, each of which is a 
 \livelink{chap:classflag}{flag}.
+\addtoindexx{call site summary information}
+\addtoindexx{subroutine call site summary attributes}
 These flags indicate the completeness of the call site information 
-within the subprogram.
+provided by call site entries (see 
+Section \refersec{chap:callsiteentries}) within the subprogram.
 
 The \DWATcallalltailcallsNAME{}
 \livetargi{chap:DWATcallalltailcallsofasubprogram}{attribute}{all tail calls summary attribute} 
@@ -1229,7 +1242,7 @@ Section \refersec{chap:codeaddressesandranges}).
 A 
 \hypertarget{chap:DWATentrypcentryaddressofsubprogram}{}
 subroutine entry may also have 
-\addtoindexx{entry pc attribute!for subroutine}
+\addtoindexx{entry PC attribute!for subroutine}
 a 
 \DWATentrypc{} attribute
 whose value is the address of the first executable instruction
@@ -1274,7 +1287,7 @@ range attributes.
 
 \subsection{Declarations Owned by Subroutines and Entry Points} 
 \label{chap:declarationsownedbysubroutinesandentrypoints}
-
+\addtoindexx{subroutine formal parameters}
 The declarations enclosed by a subroutine or entry point are
 represented by debugging information entries that are owned
 by the subroutine or entry point entry. Entries representing
@@ -1285,15 +1298,15 @@ source program.
 
 \needlines{5}
 \textit{There is no ordering requirement for entries for declarations
-that are children of subroutine or entry point entries but
-that do not represent formal parameters. The formal parameter
+other than formal parameters. The formal parameter
 entries may be interspersed with other entries used by formal
 parameter entries, such as type entries.}
 
-The unspecified parameters of a variable parameter list are
-represented by a debugging information entry\addtoindexx{unspecified parameters entry}
-with the tag
-\DWTAGunspecifiedparametersTARG.
+The unspecified (sometimes called \doublequote{varying}) 
+parameters of a subroutine parameter list are
+represented by a debugging information 
+entry\addtoindexx{unspecified parameters entry}
+with the tag \DWTAGunspecifiedparametersTARG.
 
 \needlines{4}
 The entry for a subroutine that includes a
@@ -1323,7 +1336,7 @@ subroutine or entry point entry may have
 a 
 \DWATreturnaddr{}
 attribute, whose value is a location description. The location
-calculated is the place where the return address for the
+specified is the place where the return address for the
 subroutine or entry point is stored.
 
 A 
@@ -1332,7 +1345,7 @@ subroutine or entry point entry may also have
 \addtoindexx{frame base attribute}
 a
 \DWATframebase{} attribute, whose value is a location
-description that computes the \doublequote{frame base} for the
+description that describes the \doublequote{frame base} for the
 subroutine or entry point. If the location description is
 a simple register location description, the given register
 contains the frame base address. If the location description is
@@ -1350,7 +1363,7 @@ but more
 compact. However, these are not equivalent in general.}
 
 \needlines{5}
-\textit{The frame base for a subprogram is typically an address fixed
+\textit{The frame base for a subprogram is typically an address
 relative to the first unit of storage allocated for the
 subprogram\textquoteright s stack frame. The \DWATframebase{} attribute
 can be used in several ways:}
@@ -1640,7 +1653,7 @@ inlined subroutine entry may
 also 
 \addtoindexx{inlined subprogram entry}
 contain 
-\addtoindexx{entry pc attribute!for inlined subprogram}
+\addtoindexx{entry PC attribute!for inlined subprogram}
 a 
 \DWATentrypc{}
 attribute, representing the first executable instruction of
@@ -1998,8 +2011,8 @@ and expressions where some value is no longer present in the current
 subroutine's registers or local stack frame, but it is known that the 
 values are equal to some parameter passed to the function.  
 The consumer can then use unwind
-information to find the caller and in the call site information sometimes
-find how to compute the value passed in a particular parameter.}
+information to find the caller and it's call site information and then
+compute the value passed in a particular parameter.}
 
 A call site is represented by a debugging information entry with the tag
 \DWTAGcallsiteTARG{}.  The entry for a call site is owned by the innermost
@@ -2009,22 +2022,21 @@ call is present in the source program.
 \textit{A scope entry (for example, for a lexical block) that would not 
 otherwise be present in the debugging information of a subroutine
 need not be introduced solely to represent the immediately containing scope
-of a call. The call site entry is owned by the innermost scope entry that
-is present.}
+of a call.}
 
 A source call can be compiled into different types of machine code:
 \begin{itemize}
 \item
-A \textit{normal call} uses a call-like instruction which transfers control to the start
-of some subprogram and leaves the call site location address somewhere where
-unwind information can find it.  
+A \textit{normal call} uses a call-like instruction which transfers 
+control to the start of some subprogram and leaves the call site 
+location address somewhere where unwind information can find it.  
 \item
 A \textit{tail call} uses a jump-like instruction which
 transfers control to the start of some subprogram, but the call site location
 address is not preserved (and thus not available using the unwind information).  
 \item
 A \textit{tail recursion call} is a call
-to the current subroutine which is compiled as a loop into the middle of the
+to the current subroutine which is compiled as a jump into the middle of the
 current subroutine.
 \needlines{4}
 \item
@@ -2103,7 +2115,8 @@ attribute is used instead of the \DWATcalltarget{} attribute.
 The call site entry may have a \DWATtypeNAME{}
 \livetargi{chap:DWATtypeofcallsite}{attribute}{type attribute!of call site entry}
 referencing a debugging information entry for the type of the called function.  
-When \DWATcallorigin{} is present, \DWATtypeNAME{} is usually omitted.
+
+\textit{When \DWATcallorigin{} is present, \DWATtypeNAME{} is usually omitted.}
 
 The call site entry may have 
 \DWATcallfileNAME{}, \DWATcalllineNAME{} and \DWATcallcolumnNAME{} 
@@ -2210,7 +2223,7 @@ for the lexical \nolink{block}
 A 
 \hypertarget{chap:DWATentrypcoflexicalblock}{}
 lexical block entry may also have 
-\addtoindexx{entry pc attribute!for lexical block}
+\addtoindexx{entry PC attribute!for lexical block}
 a 
 \DWATentrypc{} attribute
 whose value is the address of the first executable instruction
@@ -2298,7 +2311,7 @@ for the with statement
 A 
 \hypertarget{chap:DWATentrypcofwithstmt}{}
 with statement entry may also have 
-\addtoindexx{entry pc attribute!for with statement}
+\addtoindexx{entry PC attribute!for with statement}
 a 
 \DWATentrypc{} attribute
 whose value is the address of the first executable instruction
@@ -2355,8 +2368,8 @@ machine instructions generated for the \nolink{block}
 \hypertarget{chap:DWATentrypcoftryblock}{}
 \hypertarget{chap:DWATentrypcofcatchblock}{}
 A try or catch block entry may also have 
-\addtoindexx{entry pc attribute!for try block}
-\addtoindexx{entry pc attribute!for catch block}
+\addtoindexx{entry PC attribute!for try block}
+\addtoindexx{entry PC attribute!for catch block}
 a 
 \DWATentrypc{} attribute
 whose value is the address of the first executable instruction
index 50e63d1..356cf63 100644 (file)
@@ -500,9 +500,9 @@ example in \refersec{fig:splitobjectexamplesourcefragment3},
 \begin{tabular}{cl}
 Slot & Location referenced \\
 \hline
-   0   &  low pc value for \texttt{Box::contains}  \\
-   1   &  low pc value for \texttt{Point::x}       \\
-   2   &  low pc value for \texttt{Point::y}       \\
+   0   &  low PC value for \texttt{Box::contains}  \\
+   1   &  low PC value for \texttt{Point::x}       \\
+   2   &  low PC value for \texttt{Point::y}       \\
 \end{tabular}
 \end{center}
 
index 722b24f..10771fc 100644 (file)
@@ -6,7 +6,7 @@ user\dash defined types.
 
 If the scope of the declaration of a named type begins after
 \hypertarget{chap:DWATstartscopetypedeclaration}{}
-the low pc value for the scope most closely enclosing the
+the low PC value for the scope most closely enclosing the
 declaration, the declaration may have a 
 \DWATstartscope{}
 attribute as described for objects in 
@@ -22,29 +22,21 @@ Each programming language has a set of base
 types that are considered to be built into that language.}
 
 A base type is represented by a debugging information entry
-with the tag 
-\DWTAGbasetypeTARG.
+with the tag \DWTAGbasetypeTARG.
 
 A \addtoindex{base type entry}
-has a \DWATname{} attribute
-whose
-\addtoindexx{name attribute}
-value is
-a null\dash terminated string containing the name of the base type
+may have a \DWATname{} attribute\addtoindexx{name attribute}
+whose value is
+a null-terminated string containing the name of the base type
 as recognized by the programming language of the compilation
 unit containing the base type entry.
 
 A base type entry has 
 \addtoindexx{encoding attribute}
 a \DWATencoding{} attribute describing
-how the base type is encoded and is to be interpreted. The
-value of this attribute is an 
-\livelink{chap:classconstant}{integer constant}. The set of
-values and their meanings for the
-\DWATencoding{} attribute
-is given in 
-Table \refersec{tab:encodingattributevalues}
-and following text.  
+how the base type is encoded and is to be interpreted. 
+The \DWATencoding{} attribute is described in
+Section \referfol{chap:basetypeencodings}.
 
 A base type entry
 may have a \DWATendianity{} attribute
@@ -54,6 +46,7 @@ Section \refersec{chap:dataobjectentries}.
 If omitted, the encoding assumes the representation that
 is the default for the target architecture.
 
+\needlines{4}
 A base type entry has 
 \hypertarget{chap:DWATbytesizedataobjectordatatypesize}{}
 either a \DWATbytesize{} attribute
@@ -98,90 +91,163 @@ target system to locate the beginning of the storage and
 value. If this attribute is omitted a default data bit offset
 of zero is assumed.
 
-\textit{Attribute 
-\DWATdatabitoffset{} 
-is\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 
-\DWARFVersionIV{}, unchanged in \DWARFVersionV{}, and
-is also used for bit field members 
-(see Section \refersec{chap:datamemberentries}). 
-%\hypertarget{chap:DWATbitoffsetbasetypebitlocation}{}
-It replaces the attribute DW\_AT\_bit\_offset
-\addtoindexx{bit offset attribute (Version 3)}
-which used for base
-types as defined in \DWARFVersionIII{} and earlier.
-DW\_AT\_bit\_offset is deprecatedF
-\addtoindexx{DW\_AT\_bit\_offset (deprecated)}
-for use in base types in DWARF Version 4 and later.
-See Section 5.1 in the \DWARFVersionIV{}
-specification for a discussion of compatibility considerations.}
+A \DWTAGbasetype{} entry may have additional attributes that
+augment certain of the base type encodings; these are described
+in the following section.
 
+\subsection{Base Type Encodings}
+\label{chap:basetypeencodings}
+A base type entry has 
+\addtoindexx{encoding attribute}
+a \DWATencoding{} attribute describing
+how the base type is encoded and is to be interpreted. The 
+value of this attribute is an integer of class \CLASSconstant.
+The set of values and their meanings for the
+\DWATencoding{} attribute is given in 
+Table \refersec{tab:encodingattributevalues}.
+
+\textit{In Table \ref{tab:encodingattributevalues}, encodings
+are shown in groups that have similar characteristics purely
+for presentation purposes. These groups are not part of this
+DWARF specification.}
+
+\newcommand{\EncodingGroup}[1]{\multicolumn{2}{l}{\hspace{2cm}\bfseries\textit{#1}}}
 \begin{table}[!here]
 \caption{Encoding attribute values}
 \label{tab:encodingattributevalues}
 \centering
 \begin{tabular}{l|p{8cm}}
 \hline
-Name&Meaning\\ \hline
-\DWATEaddressTARG{} & linear machine address (for segmented\break
-  addresses see
-  Section \refersec{chap:segmentedaddresses}) \\
-\DWATEbooleanTARG& true or false \\
-
-\DWATEcomplexfloatTARG& complex binary
-floating\dash point number \\
-\DWATEfloatTARG{} & binary floating\dash point number \\
-\DWATEimaginaryfloatTARG& imaginary binary
-floating\dash point number \\
-\DWATEsignedTARG& signed binary integer \\
-\DWATEsignedcharTARG& signed character \\
-\DWATEunsignedTARG{} & unsigned binary integer \\
-\DWATEunsignedcharTARG{} & unsigned character \\
-\DWATEpackeddecimalTARG{}  & packed decimal \\
-\DWATEnumericstringTARG& numeric string \\
-\DWATEeditedTARG{} & edited string \\
-\DWATEsignedfixedTARG{} & signed fixed\dash point scaled integer \\
-\DWATEunsignedfixedTARG& unsigned fixed\dash point scaled integer \\
-\DWATEdecimalfloatTARG{} & decimal floating\dash point number \\ 
-\DWATEUTFTARG{} & \addtoindexi{Unicode character}{Unicode character base type} \\
-\DWATEASCIITARG{} & \addtoindexi{ASCII character}{ASCII character base type}\\
-\DWATEUCSTARG{} & \addtoindexi{ISO 10646 character}{ISO 10646 character base type}
-                  \addtoindexx{ISO 10646 character set standard}  \\
+\bfseries Name & \bfseries Meaning\\ \hline
+
+\EncodingGroup{Simple encodings} \\
+\DWATEbooleanTARG      & true or false \\
+\DWATEaddressTARG{}    & linear machine address$^a$ \\
+\DWATEsignedTARG       & signed binary integer \\
+\DWATEsignedcharTARG   & signed character \\
+\DWATEunsignedTARG     & unsigned binary integer \\
+\DWATEunsignedcharTARG & unsigned character \\
+
+\EncodingGroup{Character encodings} \\
+\DWATEASCIITARG{} & \addtoindex{ISO/IEC 646:1991 character} 
+                    \addtoindexx{ASCII character} \\
+\DWATEUCSTARG{}   & \addtoindex{ISO/IEC 10646-1:1993 character (UCS-4)} 
+                    \addtoindexx{UCS character} \\
+\DWATEUTFTARG{}   & \addtoindex{ISO/IEC 10646-1:1993 character}
+                    \addtoindexx{UTF character} \\
+
+\EncodingGroup{Scaled encodings} \\
+\DWATEsignedfixedTARG{} & signed fixed-point scaled integer \\
+\DWATEunsignedfixedTARG & unsigned fixed-point scaled integer \\
+
+\EncodingGroup{Floating-point encodings} \\
+\DWATEfloatTARG          & binary floating-point number \\
+\DWATEcomplexfloatTARG   & complex binary floating-point number \\
+\DWATEimaginaryfloatTARG & imaginary binary floating-point number \\
+\DWATEdecimalfloatTARG{} & \addtoindex{IEEE 754R decimal floating-point number} \\ 
+
+\EncodingGroup{Decimal string encodings} \\
+\DWATEpackeddecimalTARG & packed decimal number\\
+\DWATEnumericstringTARG & numeric string \\
+\DWATEeditedTARG        & edited string \\
+
 \hline
+\multicolumn{2}{l}{$^a$For segmented addresses, see Section \refersec{chap:segmentedaddresses}} \\
 \end{tabular}
 \end{table}
 
-\textit{The \DWATEdecimalfloat{} encoding is intended for
-floating\dash point representations that have a power\dash of\dash ten
-exponent, such as that specified in IEEE 754R.}
+\subsubsection{Simple Encodings}
+\label{simpleencodings}
+Types with simple encodings are widely supported in many
+programming languages and do not require further discussion.
 
-\textit{The \DWATEUTF{} encoding is intended for \addtoindex{Unicode}
+\needlines{6}
+\subsubsection{Character Encodings}
+\label{characterencodings}
+The \DWATEUTF{} encoding is intended for \addtoindex{Unicode}
 string encodings (see the Universal Character Set standard,
 ISO/IEC 10646\dash 1:1993).
- \addtoindexx{ISO 10646 character set standard}
+\addtoindexx{ISO 10646 character set standard}
 For example, the 
 \addtoindex{C++} type char16\_t is
 represented by a base type entry with a name attribute whose
 value is \doublequote{char16\_t}, an encoding attribute whose value
-is \DWATEUTF{} and a byte size attribute whose value is 2.}
+is \DWATEUTF{} and a byte size attribute whose value is 2.
 
-\textit{The \DWATEASCII{} and \DWATEUCS{} encodings are intended for
+\needlines{4}
+The \DWATEASCII{} and \DWATEUCS{} encodings are intended for
 the {Fortran 2003} string kinds 
 \texttt{ASCII}\index{ASCII@\texttt{ASCII} (Fortran string kind)} (ISO/IEC 646:1991) and
-\texttt{ISO\_10646}\index{ISO\_10646@\texttt{ISO\_10646} (Fortran string kind)} (UCS-4 in ISO/IEC 10646:2000).}
+\texttt{ISO\_10646}\index{ISO\_10646@\texttt{ISO\_10646} (Fortran string kind)} (UCS-4 in ISO/IEC 10646:2000).
 \addtoindexx{ISO 10646 character set standard}
 
-The 
-\DWATEpackeddecimal{} 
-and 
-\DWATEnumericstring{} 
-base types
+\subsubsection{Scaled Encodings}
+\label{scaledencodings}
+The \DWATEsignedfixed{} and \DWATEunsignedfixed{} entries
+describe signed and unsigned fixed\dash point binary data types,
+respectively.
+
+The fixed binary type encodings have a
+\DWATdigitcount{} attribute\addtoindexx{digit count attribute}
+with the same interpretation as described for the
+\DWATEpackeddecimal{} and \DWATEnumericstring{} base type encodings
+(see Section \refersec{chap:decimalstringencodings}).
+
+\needlines{4}
+For a data type with a decimal scale factor, the fixed binary
+type entry has a \DWATdecimalscale{} attribute 
+\addtoindexx{decimal scale attribute}
+with the same interpretation as described for the 
+\DWATEpackeddecimal{} and \DWATEnumericstring{} base types
+(see Section \refersec{chap:decimalstringencodings}).
+
+\hypertarget{chap:DWATbinaryscalebinaryscalefactorforfixedpointtype}{}
+For a data type with a binary scale factor, the fixed
+binary type entry has a \DWATbinaryscale{} attribute. 
+The \DWATbinaryscale{} attribute\addtoindexx{binary scale attribute} 
+is an \livelink{chap:classconstant}{integer constant} value
+that represents the exponent of the base two scale factor to
+be applied to an instance of the type.  Zero scale puts the
+binary point immediately to the right of the least significant
+bit. Positive scale moves the binary point to the right and
+implies that additional zero bits on the right are not stored
+in an instance of the type. Negative scale moves the binary
+point to the left; if the absolute value of the scale is
+larger than the number of bits, this implies additional zero
+bits on the left are not stored in an instance of the type.
+
+For 
+\hypertarget{chap:DWATsmallscalefactorforfixedpointtype}{}
+a data type with a non-decimal and non-binary scale factor,
+the fixed binary type entry has a \DWATsmall{} attribute which
+\addtoindexx{small attribute} references a 
+\DWTAGconstant{} entry. The scale factor value
+is interpreted in accordance with the value defined by the
+\DWTAGconstant{} entry. The value represented is the product
+of the integer value in memory and the associated constant
+entry for the type.
+
+\textit{The \DWATsmall{} attribute is defined with the 
+\addtoindex{Ada} \texttt{small} attribute in mind.}
+
+\needlines{6}
+\subsubsection{Floating-Point Encodings}
+\label{chap:floatingpointencodings}
+Types with binary floating-point encodings 
+(\DWATEfloat{}, \DWATEcomplexfloat{} and \DWATEimaginaryfloat{})
+are supported in many
+programming languages and do not require further discussion.
+
+The \DWATEdecimalfloat{} encoding is intended for
+floating-point representations that have a power-of-ten
+exponent, such as that specified in IEEE 754R.
+
+\subsubsection{Decimal String Encodings}
+\label{chap:decimalstringencodings}
+The \DWATEpackeddecimal{} and \DWATEnumericstring{} 
+base type encodings
 represent packed and unpacked decimal string numeric data
-types, respectively, either of which may be 
-either 
+types, respectively, either of which may be either 
 \addtoindexx{decimal scale attribute}
 signed
 \addtoindexx{decimal sign attribute}
@@ -218,9 +284,9 @@ alternatively, no sign at all.
 \hline
 \DWDSunsignedTARG{} &  Unsigned \\
 \DWDSleadingoverpunchTARG{} & Sign
-is encoded in the most significant digit in a target\dash dependent  manner \\
+is encoded in the most significant digit in a target-dependent  manner \\
 \DWDStrailingoverpunchTARG{} & Sign
-is encoded in the least significant digit in a target\dash dependent manner \\
+is encoded in the least significant digit in a target-dependent manner \\
 \DWDSleadingseparateTARG{} 
 & Decimal type: Sign is a \doublequote{+} or \doublequote{-} character 
 to the left of the most significant digit. \\
@@ -234,6 +300,7 @@ indicating positive or negative. \\
 \end{tabular}
 \end{table}
 
+\needlines{4}
 \hypertarget{chap:DWATdecimalscaledecimalscalefactor}{}
 The \DWATdecimalscale{}
 attribute 
@@ -249,16 +316,13 @@ decimal point to the left; if the absolute value of the scale
 is larger than the digit count, this implies additional zero
 digits on the left are not stored in an instance of the type.
 
-The 
-\DWATdigitcount{}
-attribute 
+The \DWATdigitcount{} attribute 
 \addtoindexx{digit count attribute}
 is an \livelink{chap:classconstant}{integer constant}
 value that represents the number of digits in an instance of
 the type.
 
-The \DWATEedited{}
-base 
+The \DWATEedited{} base 
 \hypertarget{chap:DWATpicturestringpicturestringfornumericstringtype}{}
 type is used to represent an edited
 numeric or alphanumeric data type. It is used in combination
@@ -268,8 +332,7 @@ string associated with the type.
 
 If the edited base type entry describes an edited numeric
 data type, the edited type entry has a \DWATdigitcount{} and a
-\DWATdecimalscale{} attribute. 
-\addtoindexx{decimal scale attribute}
+\DWATdecimalscale{} attribute.\addtoindexx{decimal scale attribute}
 These attributes have the same
 interpretation as described for the 
 \DWATEpackeddecimal{} and
@@ -278,70 +341,13 @@ types. If the edited type entry
 describes an edited alphanumeric data type, the edited type
 entry does not have these attributes.
 
-
 \textit{The presence or absence of the \DWATdigitcount{} and
-\DWATdecimalscale{} attributes 
-\addtoindexx{decimal scale attribute}
+\DWATdecimalscale{} attributes\addtoindexx{decimal scale attribute}
 allows a debugger to easily
 distinguish edited numeric from edited alphanumeric, although
 in principle the digit count and scale are derivable by
 interpreting the picture string.}
 
-The \DWATEsignedfixed{} and \DWATEunsignedfixed{} entries
-describe signed and unsigned fixed\dash point binary data types,
-respectively.
-
-The fixed binary type entries have 
-\addtoindexx{digit count attribute}
-a 
-\DWATdigitcount{}
-attribute with the same interpretation as described for the
-\DWATEpackeddecimal{} and \DWATEnumericstring{} base types.
-
-\needlines{4}
-For a data type with a decimal scale factor, the fixed binary
-type entry has a 
-\DWATdecimalscale{} attribute 
-\addtoindexx{decimal scale attribute}
-with the same
-interpretation as described for the 
-\DWATEpackeddecimal{}
-and \DWATEnumericstring{} base types.
-
-\hypertarget{chap:DWATbinaryscalebinaryscalefactorforfixedpointtype}{}
-For a data type with a binary scale factor, the fixed
-\addtoindexx{binary scale attribute}
-binary type entry has a 
-\DWATbinaryscale{} attribute. 
-The
-\DWATbinaryscale{} attribute 
-is an \livelink{chap:classconstant}{integer constant} value
-that represents the exponent of the base two scale factor to
-be applied to an instance of the type.  Zero scale puts the
-binary point immediately to the right of the least significant
-bit. Positive scale moves the binary point to the right and
-implies that additional zero bits on the right are not stored
-in an instance of the type. Negative scale moves the binary
-point to the left; if the absolute value of the scale is
-larger than the number of bits, this implies additional zero
-bits on the left are not stored in an instance of the type.
-
-For 
-\hypertarget{chap:DWATsmallscalefactorforfixedpointtype}{}
-a data type with a non\dash decimal and non\dash binary scale factor,
-the fixed binary type entry has a 
-\DWATsmall{} attribute which
-\addtoindexx{small attribute}
-references a 
-\DWTAGconstant{} entry. The scale factor value
-is interpreted in accordance with the value defined by the
-\DWTAGconstant{} entry. The value represented is the product
-of the integer value in memory and the associated constant
-entry for the type.
-
-\textit{The \DWATsmall{} attribute 
-is defined with the \addtoindex{Ada} \texttt{small}
-attribute in mind.}
 
 \section{Unspecified Type Entries}
 \label{chap:unspecifiedtypeentries}
@@ -608,7 +614,7 @@ have a \DWATordering{} attribute whose
 interpreted to mean either row-major or column-major ordering
 of array elements. The set of values and their meanings
 for the ordering attribute are listed in 
-Table \refersec{tab:arrayordering}. 
+Table \referfol{tab:arrayordering}. 
 If no
 ordering attribute is present, the default ordering for the
 source language (which is indicated by the 
@@ -700,7 +706,7 @@ Other attributes especially applicable to arrays are
 \DWATassociated{} and 
 \DWATdatalocation,
 which are described in 
-Section \refersec{chap:dynamictypeproperties}. 
+Section \refersec{chap:dynamicpropertiesoftypes}. 
 For relevant examples, see also Appendix \refersec{app:fortranarrayexample}.
 
 \section{Coarray Type Entries}
@@ -735,7 +741,7 @@ concept in DWARF, the \DWTAGsubrangetype{} child entry for that index has
 only a lower bound and no upper bound.}
 
 \textit{How coarray elements are located and how coindices are 
-converted to process specifications is implementation-dependent.}
+converted to process specifications is implementation-defined.}
 
 \needlines{8}
 \section{Structure, Union, Class and Interface Type Entries}
@@ -888,7 +894,7 @@ 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
-about the location of that member (low and high pc attributes
+about the location of that member (low and high PC attributes
 for function members, location descriptions for data members)
 and will have a \DWATdeclaration{} attribute.
 
@@ -1092,18 +1098,15 @@ entities.
 \subsection{Friends}
 \label{chap:friends}
 
-Each \doublequote{friend} 
-\addtoindexx{friend entry}
+Each friend\addtoindexx{friend entry}
 declared by a structure, union or class
 \hypertarget{chap:DWATfriendfriendrelationship}{}
 type may be represented by a debugging information entry
 that is a child of the structure, union or class type entry;
-the friend entry has the 
-tag \DWTAGfriendTARG.
+the friend entry has the tag \DWTAGfriendTARG.
 
-A friend entry has 
-\addtoindexx{friend attribute}
-a \DWATfriend{} attribute, whose value is
+A friend entry has a \DWATfriendTARG{} attribute,
+\addtoindexx{friend attribute} whose value is
 a reference to the debugging information entry describing
 the declaration of the friend.
 
@@ -1126,20 +1129,15 @@ program. If the member entry describes an
 the name attribute is omitted or the value of the attribute
 consists of a single zero byte.
 
-The data member entry has 
-\addtoindexx{type attribute}
-a 
-\DWATtype{} attribute to denote
-\addtoindexx{member entry (data)}
-the type of that member.
+The data member entry has a 
+\DWATtype{} attribute\addtoindexx{type attribute} to denote
+\addtoindexx{member entry (data)} the type of that member.
 
-A data member entry may 
-\addtoindexx{accessibility attribute}
-have a 
-\DWATaccessibility{}
-attribute. If no accessibility attribute is present, private
-access is assumed for an entry of a class and public access
-is assumed for an entry of a structure, union, or interface.
+A data member entry may have a \DWATaccessibility{}
+attribute.\addtoindexx{accessibility attribute} 
+If no accessibility attribute is present, private
+access is assumed for an member of a class and public access
+is assumed for an member of a structure, union, or interface.
 
 A data member 
 \hypertarget{chap:DWATmutablemutablepropertyofmemberdata}{}
@@ -1234,150 +1232,17 @@ per byte.
 
 If the size of a data member is not the same as the size
 of the type given for the data member, the data member has
-\addtoindexx{bit size attribute}
-either a \DWATbytesize{} 
-or a \DWATbitsize{} attribute whose
+either a \DWATbytesize\addtoindexx{byte size attribute} 
+or a \DWATbitsize{} attribute\addtoindexx{bit size attribute} whose
 \livelink{chap:classconstant}{integer constant} value 
 (see Section \refersec{chap:staticanddynamicvaluesofattributes}) 
 is the amount
 of storage needed to hold the value of the data member.
 
-\textit{Bit fields in \addtoindex{C} and \addtoindex{C++} 
-typically 
-\addtoindexx{bit fields} 
-require the use 
-\addtoindexx{data bit offset}
-of 
-\addtoindexx{data bit size}
-the
-\DWATdatabitoffset{} and 
-\DWATbitsize{} attributes.}
-
-\needlines{6}
-\textit{This Standard uses the following bit numbering and direction
-conventions in examples. These conventions are for illustrative
-purposes and other conventions may apply on particular
-architectures.}
-\begin{itemize}
-\item \textit{For big\dash endian architectures, bit offsets are
-counted from high-order to low\dash order bits within a byte (or
-larger storage unit); in this case, the bit offset identifies
-the high\dash order bit of the object.}
-
-\item \textit{For little\dash endian architectures, bit offsets are
-counted from low\dash order to high\dash order bits within a byte (or
-larger storage unit); in this case, the bit offset identifies
-the low\dash order bit of the object.}
-\end{itemize}
-
-
-\textit{In either case, the bit so identified is defined as the 
-\addtoindexx{beginning of an object}
-beginning of the object.}
-
-\needlines{5}
-\textit{For example, take one possible representation of the following 
-\addtoindex{C} structure definition 
-in both big\dash and little\dash endian byte orders:}
-
-\begin{lstlisting}
-struct S {
-    int j:5;
-    int k:6;
-    int m:5;
-    int n:8;
-};
-\end{lstlisting}
-
-\textit{Figures \referfol{fig:bigendiandatabitoffsets} and
-\refersec{fig:littleendiandatabitoffsets}
-show the structure layout
-and data bit offsets for example big\dash\   and little\dash endian
-architectures, respectively. Both diagrams show a structure
-that begins at address A and whose size is four bytes. Also,
-high order bits are to the left and low order bits are to
-the right.}
-
-\begin{figure}[h]
-\begin{dwflisting}
-\begin{verbatim}
-
-    j:0
-    k:5
-    m:11
-    n:16
-
-    Addresses increase ->
-    |       A       |     A + 1     |    A + 2      |    A + 3      | 
-
-    Data bit offsets increase ->
-    +---------------+---------------+---------------+---------------+
-    |0     4|5         10|11      15|16           23|24           31|
-    |   j   |     k      | m        |        n      |       <pad>   |
-    |       |            |          |               |               | 
-    +---------------------------------------------------------------+ 
+\textit{For showing nested and packed records and arrays, 
+see Appendix \refersec{app:pascalexample} and 
+\refersec{app:ccppbitfieldexamples}.}
 
-\end{verbatim}
-\end{dwflisting}
-\caption{Big-endian data bit offsets}
-\label{fig:bigendiandatabitoffsets}
-\end{figure}
-
-\begin{figure}[h]
-\begin{dwflisting}
-\begin{verbatim}
-
-    j:0
-    k:5
-    m:11
-    n:16
-                                               <- Addresses increase
-    |     A + 3     |     A + 2     |    A + 1      |       A       | 
-
-                                        <-  Data bit offsets increase 
-    +---------------+---------------+---------------+---------------+
-    |31           24|23           16|15     11|10       5|4        0|
-    |     <pad>     |        n      |    m    |    k     |     j    |
-    |               |               |         |          |          |
-    +---------------------------------------------------------------+
-
-\end{verbatim}
-\end{dwflisting}
-\caption{Little-endian data bit offsets}
-\label{fig:littleendiandatabitoffsets}
-\end{figure}
-
-\needlines{4}
-\textit{Note that data member bit offsets in this example are the
-same for both big\dash\ and little\dash endian architectures even
-though the fields are allocated in different directions
-(high\dash order to low-order versus low\dash order to high\dash order);
-the bit naming conventions for memory and/or registers of
-the target architecture may or may not make this seem natural.}
-
-\textit{For a more extensive example showing nested and packed records
-and arrays, see 
-Appendix \refersec{app:pascalexample}.}
-
-\needlines{4}
-\textit{Attribute \DWATdatabitoffset{} 
-is new in 
-\addtoindex{DWARF Version 4}, unchanged in \DWARFVersionV,
-and is also used for base types 
-(see Section 
-\refersec{chap:basetypeentries}). 
-%\livetarg{chap:DWATbitoffsetdatamemberbitlocation}{}
-It replaces the attributes 
-DW\_AT\_bit\_offset\addtoindexx{bit offset attribute (Version 3)}
-and \DWATbytesize{} when used to
-identify the beginning of bit field data members as defined
-in \DWARFVersionIII{} and earlier. The 
-\DWATbytesize, 
-\DWATbitsize{} and 
-DW\_AT\_bit\_offset\addtoindexx{DW\_AT\_bit\_offset (deprecated)}
-attribute combination is deprecated for data members in 
-\DWARFVersionIV{} and later. See Section 5.6.6 in the \DWARFVersionIV{}
-specification for a discussion of compatibility considerations.}
 
 \subsection{Member Function Entries}
 \label{chap:memberfunctionentries}
@@ -1644,9 +1509,9 @@ a debugging information entry\addtoindexx{variant entry} with the
 tag \DWTAGvariantTARG{}
 and is a child of the variant part entry. The value that
 selects a given variant may be represented in one of three
-ways. The variant entry may have a 
-\DWATdiscrvalue{} attribute
-whose value represents a single case label. The value of this
+ways. The variant entry may have a \DWATdiscrvalue{} attribute
+whose value represents the discriminant value selecting 
+this variant. The value of this
 attribute is encoded as an LEB128 number. The number is signed
 if the tag type for the variant part containing this variant
 is a signed type. The number is unsigned if the tag type is
@@ -1657,13 +1522,12 @@ Alternatively,
 \hypertarget{chap:DWATdiscrlistlistofdiscriminantvalues}{}
 the variant entry may contain 
 \addtoindexx{discriminant list attribute}
-a 
-\DWATdiscrlist{}
+a \DWATdiscrlist{}
 attribute, whose value represents a list of discriminant
 values. This list is represented by any of the 
-\livelink{chap:classblock}{block} forms and
-may contain a mixture of case labels and label ranges. Each
-item on the list is prefixed with a discriminant value
+\livelink{chap:classblock}{block} forms and may contain a 
+mixture of discriminant values and discriminant ranges. 
+Each item on the list is prefixed with a discriminant value
 descriptor that determines whether the list item represents
 a single label or a label range. A single case label is
 represented as an LEB128 number as defined above for 
@@ -1823,8 +1687,8 @@ such entry is a child of the
 enumerator entries appear in the same order as the declarations
 of the enumeration literals in the source program.
 
-Each \addtoindex{enumerator entry} has a 
-\DWATname{} attribute, whose
+\needlines{4}
+Each \addtoindex{enumerator entry} has a \DWATname{} attribute, whose
 \addtoindexx{name attribute}
 value is a null\dash terminated string containing the name of the
 \hypertarget{chap:DWATconstvalueenumerationliteralvalue}{}
@@ -1834,7 +1698,6 @@ Each enumerator entry also has a
 whose value is the actual numeric value of the enumerator as
 represented on the target system.
 
-
 If the enumeration type occurs as the description of a
 \addtoindexx{enumeration type entry!as array dimension}
 dimension of an array type, and the stride for that dimension
@@ -1911,6 +1774,7 @@ a
 \DWATprototyped{} attribute, which is
 a \livelink{chap:classflag}{flag}.
 
+\needlines{4}
 Each debugging information entry owned by a subroutine
 type entry corresponds to either a formal parameter or the sequence of
 unspecified parameters of the subprogram type:
@@ -2012,13 +1876,13 @@ allocated for the string (as specified by the \DWATbytesize{}
 or \DWATbitsize{} attribute).
 
 The string type entry may also have a 
-\DWATstringlengthbytesizeNAME{}
-attribute or
+\DWATstringlengthbytesizeNAME{} or
 \DWATstringlengthbitsizeNAME{} attribute,
+\addtoindexx{string length size attribute}
 \addtoindexx{string length attribute!size of length data}
 whose value (see Section \refersec{chap:byteandbitsizes}) 
 is the size of the data to be retrieved from the location
-referenced by the string length attribute. If no (byte or bit)
+referenced by the \DWATstringlength{} attribute. If no byte or bit
 size attribute is present, the size of the data to be retrieved
 is the same as the 
 \addtoindex{size of an address} on the target machine.
@@ -2076,31 +1940,26 @@ the amount of storage needed to hold a value of the set type.
 \label{chap:subrangetypeentries}
 
 \textit{Several languages support the concept of a \doublequote{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
-the bounds of array dimensions.}
+type. Objects of the subrange type can represent only a contiguous 
+subset (range) of values from the type on which the subrange is defined.
+Subrange types 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 \DWTAGsubrangetypeTARG. 
-If a name has been
-given to the subrange type, then the subrange type entry
-has a \DWATname{} attribute
-\addtoindexx{name attribute}
-whose value is a null\dash terminated
+entry with the tag 
+\DWTAGsubrangetypeTARG.\addtoindexx{subrange type entry} 
+If a name has been given to the subrange type, then the 
+subrange type entry has a 
+\DWATname{} attribute\addtoindexx{name attribute}
+whose value is a null-terminated
 string containing the subrange type name as it appears in
 the source program.
 
-The tag \DWTAGgenericsubrange{} is
-used to describe arrays with a dynamic rank. See Section
+The tag \DWTAGgenericsubrange{}
+is used to describe arrays with a dynamic rank. See Section
 \refersec{chap:DWTAGgenericsubrange}.
 
-The subrange entry may have 
-\addtoindexx{type attribute}
-a \DWATtype{} attribute to describe
+The subrange entry may have a 
+\DWATtype{} attribute\addtoindexx{type attribute} to describe
 the type of object, called the basis type, of whose values
 this subrange is a subset.
 
@@ -2113,19 +1972,16 @@ type entry has a
 \DWATbitsize{}
 attribute, whose value 
 (see Section \refersec{chap:staticanddynamicvaluesofattributes})
-is the amount of
-storage needed to hold a value of the subrange type.
+is the amount of storage needed to hold a value of the subrange type.
 
 The 
 \hypertarget{chap:DWATthreadsscaledupcarrayboundthreadsscalfactor}{}
-subrange entry may have 
-\addtoindexx{threads scaled attribute}
-a 
-\DWATthreadsscaled{} attribute,
+subrange entry may have a 
+\DWATthreadsscaled{} attribute\addtoindexx{threads scaled attribute},
 which is a \livelink{chap:classflag}{flag}. 
 If present, this attribute indicates whether
 this subrange represents a \addtoindex{UPC} array bound which is scaled
-by the runtime THREADS value (the number of \addtoindex{UPC} threads in
+by the runtime \texttt{THREADS} value (the number of \addtoindex{UPC} threads in
 this execution of the program).
 
 \textit{This allows the representation of a \addtoindex{UPC} shared array such as}
@@ -2134,6 +1990,7 @@ this execution of the program).
 int shared foo[34*THREADS][10][20];
 \end{lstlisting}
 
+\needlines{4}
 The 
 \hypertarget{chap:DWATlowerboundlowerboundofsubrange}{}
 subrange 
@@ -2316,17 +2173,16 @@ The file type entry also has a
 (see Section \refersec{chap:staticanddynamicvaluesofattributes})
 is the amount of storage need to hold a value of the file type.
 
-\section{Dynamic Type Entries and Properties}
-
-\subsection{Dynamic Type Entries}
+\section{Dynamic Type Entries}
+\label{chap:dynamictypeentries}
 \textit{Some languages such as 
 \addtoindex{Fortran 90}, provide types whose values
 may be dynamically allocated or associated with a variable
-under explicit program control. However, unlike the related
+under explicit program control. However, unlike the
 pointer type in \addtoindex{C} or 
 \addtoindex{C++}, the indirection involved in accessing
 the value of the variable is generally implicit, that is, not
-indicated as part of program source.}
+indicated as part of the program source.}
 
 A dynamic type entry is used to declare a dynamic type that is 
 \doublequote{just like} another non-dynamic type without needing to
@@ -2343,20 +2199,43 @@ reference to the type of the entities that are dynamically allocated.
        
 A dynamic type entry also has a \DWATdatalocation, and may also
 have \DWATallocated{} and/or \DWATassociated{} attributes as 
-described in Section \referfol{chap:dynamictypeproperties}. 
+described in Section \refersec{chap:dynamicpropertiesoftypes}. 
 A \DWATdatalocation, \DWATallocated{} or \DWATassociated{} attribute 
 may not occur on a dynamic type entry if the same kind of attribute 
 already occurs on the type referenced by the \DWATtype{} attribute.
 
-\subsection{Dynamic Type Properties}
-\label{chap:dynamictypeproperties}
-\textit{
-The \DWATdatalocation, \DWATallocated{} and \DWATassociated{} 
-attributes described in this section can be used for any type, not
-just dynamic types.}
 
 \needlines{6}
-\subsubsection{Data Location}
+\section{Template Alias Entries}
+\label{chap:templatealiasentries}
+
+\textit{In \addtoindex{C++}, a template alias is a form of typedef that has template
+parameters.  DWARF does not represent the template alias definition
+but does represent instantiations of the alias.}
+
+A type named using a template alias is represented
+by a debugging information entry 
+\addtoindexx{template alias entry}
+with the tag
+\DWTAGtemplatealiasTARG. 
+The template alias entry has a
+\DWATname{} attribute 
+\addtoindexx{name attribute}
+whose value is a null\dash terminated string
+containing the name of the template alias as it appears in
+the source program.
+The template alias entry has child entries describing the template
+actual parameters (see Section \refersec{chap:templateparameters}).
+
+
+\section{Dynamic Properties of Types}
+\label{chap:dynamicpropertiesoftypes}
+\textit{The \DWATdatalocation, \DWATallocated{} and \DWATassociated{}
+attributes described in this section are motivated for use with
+\DWTAGdynamictype{} entries but can be used for any other type as well.}
+
+\needlines{6}
+\subsection{Data Location}
 \label{chap:datalocation}
 
 \textit{Some languages may represent objects using descriptors to hold
@@ -2387,7 +2266,7 @@ calculation. For an example using
 for a \addtoindex{Fortran 90 array}, see 
 Appendix \refersec{app:fortranarrayexample}.}
 
-\subsubsection{Allocation and Association Status}
+\subsection{Allocation and Association Status}
 \label{chap:allocationandassociationstatus}
 
 \textit{Some languages, such as \addtoindex{Fortran 90},
@@ -2396,11 +2275,8 @@ may be dynamically allocated or associated with a variable
 under explicit program control.}
 
 \hypertarget{chap:DWATallocatedallocationstatusoftypes}{}
-The 
-\DWATallocated{} 
-attribute 
-\addtoindexx{allocated attribute}
-may optionally be used with any
+The \DWATallocated{} attribute\addtoindexx{allocated attribute}
+may be used with any
 type for which objects of the type can be explicitly allocated
 and deallocated. The presence of the attribute indicates that
 objects of the type are allocatable and deallocatable. The
@@ -2421,11 +2297,6 @@ indicates that objects of the type can be associated. The
 integer value of the attribute (see below) indicates whether
 an object of the type is currently associated or not.
 
-\textit{While these attributes are defined specifically with 
-\addtoindex{Fortran 90} ALLOCATABLE and POINTER types
-in mind, usage is not limited
-to just that language.}
-
 The value of these attributes is determined as described in
 Section \refersec{chap:staticanddynamicvaluesofattributes}.
 
@@ -2453,14 +2324,14 @@ pointer assignment.}
 arrays, 
 see Appendix \refersec{app:aggregateexamples}.}
 
-\subsubsection{Array Rank}
+\subsection{Array Rank}
 \label{chap:DWATrank}
 \addtoindexx{array!assumed-rank}
 \addtoindexx{assumed-rank array|see{array, assumed-rank}}
 \textit{The Fortran language supports \doublequote{assumed-rank arrays}. The
   rank (the number of dimensions) of an assumed-rank array is unknown
-  at compile time. The Fortran runtime stores the rank in the array
-  descriptor metadata.}
+  at compile time. The Fortran runtime stores the rank in an array
+  descriptor.}
 
 The presence of the
 \hypertarget{chap:DWATrankofdynamicarray}{\DWATrankINDX}
@@ -2481,7 +2352,7 @@ expression is to be evaluated needs to be pushed onto the stack. The
 expression will use it to find the offset of the respective field in
 the array descriptor metadata.
 
-\textit{The Fortran compiler is free to choose any layout for the
+\textit{A producer is free to choose any layout for the
   array descriptor. In particular, the upper and lower bounds and
   stride values do not need to be bundled into a structure or record,
   but could be laid end to end in the containing descriptor, pointed
@@ -2494,27 +2365,3 @@ order.
 \textit{For an example in Fortran 2008, see
   Section~\refersec{app:assumedrankexample}.}
 
-\needlines{6}
-\section{Template Alias Entries}
-\label{chap:templatealiasentries}
-
-\textit{
-In \addtoindex{C++}, a template alias is a form of typedef that has template
-parameters.  DWARF does not represent the template alias definition
-but does represent instantiations of the alias.
-}
-
-A type named using a template alias is represented
-by a debugging information entry 
-\addtoindexx{template alias entry}
-with the tag
-\DWTAGtemplatealiasTARG. 
-The template alias entry has a
-\DWATname{} attribute 
-\addtoindexx{name attribute}
-whose value is a null\dash terminated string
-containing the name of the template alias as it appears in
-the source program.
-The template alias entry has child entries describing the template
-actual parameters (see Section \refersec{chap:templateparameters}).
-