Backup of working files incorporating changes from editorial review
authorRon Brender <ron.brender@gmail.com>
Sun, 18 Oct 2015 21:41:05 +0000 (17:41 -0400)
committerRon Brender <ron.brender@gmail.com>
Sun, 18 Oct 2015 21:41:05 +0000 (17:41 -0400)
meetings of Oct 7-8, 2015. Not intended as a general release at this
time.

Signed-off-by: Ron Brender <ron.brender@gmail.com>
dwarf5/latexdoc/changesummary.tex
dwarf5/latexdoc/compression.tex
dwarf5/latexdoc/dataobject.tex
dwarf5/latexdoc/datarepresentation.tex
dwarf5/latexdoc/dwarf5.tex
dwarf5/latexdoc/examples.tex
dwarf5/latexdoc/generaldescription.tex
dwarf5/latexdoc/otherdebugginginformation.tex
dwarf5/latexdoc/programscope.tex
dwarf5/latexdoc/splitobjects.tex
dwarf5/latexdoc/typeentries.tex

index 82e0069..dc62ba7 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
+10/14-18/2015   & Editorial work from group review II, including fix double spaces problems \\
 8/26-28/2015    & Editorial work from group review \\
 8/17/2015       & Editorial work XI \\
 7/28-8/11/2015  & 150623.1 (MD5 digest), new F.3 (.dwp files), remove trial Selected Glossary, \\
@@ -60,7 +61,7 @@ This change summary is included only in draft versions of this document.
                 & 140331.1 (noreturn attribute) \\
 5/13/2014       & 100909.1 (entry values), 100909.2 (call sites), \\
                 & 140327.1 (Clarification of enumeration size) \\
-4/25/2014       & 140330.1 (C++:2011), 14037.1 (enumeration size) \\
+4/25/2014       & 140330.1 (C++11), 14037.1 (enumeration size) \\
 4/19/2014       & Complete revisions to Appendix B (especially for .debug\_macro) \\
 4/17/2014       & 110722.1 (.debug\_macro), Clean up missing target issues \\
 4/15/2014       & 140129.1 (Rust), 140203.1 (hashing of \DWFORMexprlocNAME) \\
@@ -81,7 +82,7 @@ This change summary is included only in draft versions of this document.
                & 120727.1 (\DWATuseUTFeightNAME{} affects all sections),       \\
                & 130402.1 (\DWATdefaultvalueNAME{} flag on template parameters),       \\
                & 130412.1 (non-integral non-type template parameters), 131009.1 (OCaml)        \\
-10/22/2013     & 120628.1 (language codes for C++:2003 and 2011)       \\
+10/22/2013     & 120628.1 (language codes for C++03 and 2011)  \\
 10/11/2013     & Several DW<name>TARG repairs          \\
 10/10/2013     & Convert document to use new DWARF name commands (dwarfnamecmds.tex) \\
 10/2/2013      & Fill out the rest of dwarfnamecmds.tex                                        \\
index af32f0b..b2821eb 100644 (file)
@@ -233,7 +233,7 @@ the same
 \textless gid\dash number\textgreater,
 and
 
-\item  a non\dash matching output (say because of \texttt{\#defines})
+\item  a non-matching output (say because of \texttt{\#defines})
 generates a different 
 \textless gid\dash number\textgreater.
 \end{itemize}
index 8d5f141..8ae3b75 100644 (file)
@@ -29,18 +29,16 @@ formal parameter or constant may have the following attributes:
 \item A \DWATname{} attribute,
 \addtoindexx{name attribute}
 whose value is a null-terminated string containing the data object 
-name as it appears in the source program.
+name.\bbeb
 
 If a variable entry describes an anonymous object (for example
 an \addtoindex{anonymous union}),
 the name attribute is omitted or its value consists of a single
 zero byte.
 
-\item A \DWATexternalDEFN{} attribute, 
-\hypertarget{chap:DWATexternalexternalvariable}{}
-which 
-\addtoindexx{external attribute}
-is a \livelink{chap:classflag}{flag}, if the name
+\item \hypertarget{chap:DWATexternalexternalvariable}{}
+A \DWATexternalDEFN{} attribute,\addtoindexx{external attribute} 
+which is a \livelink{chap:classflag}{flag}, if the name
 of a variable is visible outside of its enclosing compilation
 unit.  
 
@@ -112,14 +110,11 @@ the \DWATspecification{} attribute do not need to duplicate
 information provided by the declaration entry referenced by
 the specification attribute. In particular, such variable
 entries do not need to contain attributes for the name or
-type of the data member whose definition they 
-% Getting the link target in a good spot is tricky. So putting
-%this one a little early.
-\hypertarget{chap:DWATvariableparameternonconstantparameterflag}{}
-represent.
+type of the data member whose definition they represent.
 
 \needlines{4}
-\item A \DWATvariableparameterDEFN{}
+\item \hypertarget{chap:DWATvariableparameternonconstantparameterflag}{}
+A \DWATvariableparameterDEFN{}
 attribute\addtoindexx{variable parameter attribute}, 
 which is a \livelink{chap:classflag}{flag},
 if a formal parameter entry represents a parameter whose
@@ -127,24 +122,23 @@ value in the calling function may be modified by the callee.
 The absence of this attribute implies that the parameter\textquoteright s
 value in the calling function cannot be modified by the callee.
 
-\item A \DWATisoptionalDEFN{} attribute, 
-\hypertarget{chap:DWATisoptionaloptionalparameter}{}
-which 
-\addtoindexx{is optional attribute}
-is a \livelink{chap:classflag}{flag}, if a
+\item \hypertarget{chap:DWATisoptionaloptionalparameter}{}
+A \DWATisoptionalDEFN{} attribute,\addtoindexx{is optional attribute} 
+which is a \livelink{chap:classflag}{flag}, if a
 parameter entry represents an \addtoindex{optional parameter}.
 
-\item A \DWATdefaultvalueDEFN{} attribute 
-\addtoindexx{default value attribute}
-for 
-\addtoindexx{formal parameter entry!with default value}
-a formal parameter
-\hypertarget{chap:DWATdefaultvaluedefaultvalueofparameter}{}
-entry. The value of this attribute may be a constant, or a reference to the
+\item \hypertarget{chap:DWATdefaultvaluedefaultvalueofparameter}{}
+A \DWATdefaultvalueDEFN{} attribute\addtoindexx{default value attribute}
+for \addtoindexx{formal parameter entry!with default value}
+a formal parameter entry. 
+The value of this attribute may be a constant, or a reference to the
 debugging information entry for a variable, or a reference to a
 debugging information entry containing a DWARF procedure.  If the
 attribute form is of class constant, that constant is interpreted as
-a default value of the type of the formal parameter. If the attribute
+\bb
+a value whose type is the same as
+\eb
+the type of the formal parameter. If the attribute
 form is of class reference, and the referenced entry is for a
 variable, the default value of the parameter is the value of the
 referenced variable.  If the reference value is 0, no default value
@@ -157,9 +151,9 @@ parameter.
 \textit{For a constant form there is no way to 
 express the absence of a default value.}
 
-\item A \DWATconstvalueDEFN{} attribute
+\item \hypertarget{chap:DWATconstvalueconstantobject}{}
+A \DWATconstvalueDEFN{} attribute
 \addtoindexx{constant value attribute}  
-\hypertarget{chap:DWATconstvalueconstantobject}{}
 for an entry describing a
 variable or formal parameter whose value is constant and not
 represented by an object in the address space of the program,
@@ -178,14 +172,18 @@ formal parameter of an inlined subprogram that corresponds
 to a constant actual parameter of a call that is inlined.
 }
 
-\item A \DWATstartscopeDEFN{}\addtoindexx{start scope attribute}
-\hypertarget{chap:DWATstartscopeobjectdeclaration}{}
+\item \hypertarget{chap:DWATstartscopeobjectdeclaration}{}
+A \DWATstartscopeDEFN{}\addtoindexx{start scope attribute}
 attribute if the address range for the scope of an
 object is a subset of the address range for the
 the lexical scope most closely enclosing the object. 
 There are two cases:
 \begin{enumerate}[a) ]
-\item If address range for the scope of the object entry 
+\item If 
+\bb
+the
+\eb
+address range for the scope of the object entry 
 includes all of addresses for the containing scope except 
 for a contiguous sequence of bytes at the beginning of the 
 address range for the containing scope, then the address is 
@@ -238,11 +236,11 @@ the full declarator for the local x.}
 non-contiguous and require use of a \addtoindex{range list} even when
 the containing scope is contiguous. Conversely, the scope of
 an object may not require its own \addtoindex{range list} even when the
-containing scope is non\dash contiguous.}
+containing scope is non-contiguous.}
 
-\item A \DWATendianityDEFN{} attribute,
+\item \hypertarget{chap:DWATendianityendianityofdata}{}
+A \DWATendianityDEFN{} attribute,
 \addtoindexx{endianity attribute}
-\hypertarget{chap:DWATendianityendianityofdata}{}
 whose value is a constant that 
 \addtoindexx{big-endian encoding|see{endianity attribute}}
 specifies the endianity of the object. The value of
@@ -278,9 +276,9 @@ exact definition of these formats may differ in subtle ways
 for different architectures.
 
 \needlines{6}
-\item A \DWATconstexprDEFN{} attribute,
+\item \hypertarget{chap:DWATconstexprcompiletimeconstantobject}{}
+A \DWATconstexprDEFN{} attribute,
 \addtoindex{constant expression attribute}
-\hypertarget{chap:DWATconstexprcompiletimeconstantobject}{}
 which is a \CLASSflag, if a
 variable entry represents a \addtoindex{C++} object declared with the
 \texttt{constexpr} specifier. This attribute indicates that the
@@ -314,9 +312,10 @@ entry has a \DWATname{} attribute
 whose value is a null-terminated
 string containing the
 \livetargi{chap:commonblockreferenceattribute}{common block}{common block reference attribute} 
-name as it appears in the source program. It may also have a
-\DWATlinkagename{} attribute as described in 
-Section \refersec{chap:linkagenames}. 
+name.
+\bbeb
+It may also have a \DWATlinkagename{} attribute as described 
+in Section \refersec{chap:linkagenames}. 
 
 A common block entry also has a \DWATlocation{} attribute
 \addtoindexx{location attribute}
@@ -347,10 +346,10 @@ name, the namelist entry has a \DWATname{} attribute,
 \addtoindexx{name attribute}
 whose value is a null-terminated
 string containing the namelist\textquoteright{}s
-name as it appears in the source program.
+name.
+\bbeb
 
-Each 
-\hypertarget{chap:DWATnamelistitemnamelistitem}{}
+Each\hypertarget{chap:DWATnamelistitemnamelistitem}{}
 name that is part of the namelist is represented
 by a debugging information entry with the tag
 \DWTAGnamelistitemTARG. 
index 8c1c8d4..abb7005 100644 (file)
@@ -18,11 +18,11 @@ special labels are reserved for tag names, attribute names,
 base type encodings, location operations, language names,
 calling conventions and call frame instructions.
 
-The labels denoting the beginning and end of the reserved
-\hypertarget{chap:DWXXXlohiuser}{}
-value range for vendor specific extensions consist of the
+The labels denoting the beginning and end of the 
+\hypertarget{chap:DWXXXlohiuser}{reserved value range}
+for vendor specific extensions consist of the
 appropriate prefix 
-(\DWATlouserMARK{}\DWAThiuserMARK{}    DW\_AT,
+(\DWATlouserMARK{}\DWAThiuserMARK{}DW\_AT,
 \DWATElouserMARK{}\DWATEhiuserMARK{}   DW\_ATE, 
 \DWCClouserMARK{}\DWCChiuserMARK{}     DW\_CC,
 \DWCFAlouserMARK{}\DWCFAhiuserMARK{}   DW\_CFA 
@@ -119,8 +119,11 @@ In an \addtoindex{initial length} field, the values \wfffffffzero through
 \wffffffff are reserved by DWARF to indicate some form of
 extension relative to \DWARFVersionII; such values must not
 be interpreted as a length field. The use of one such value,
-\xffffffff, is defined below 
-(see Section \refersec{datarep:32bitand64bitdwarfformats}); 
+\xffffffff, is defined 
+\bb
+in
+\eb
+Section \refersec{datarep:32bitand64bitdwarfformats}); 
 the use of
 the other values is reserved for possible future extensions.
 
@@ -714,8 +717,8 @@ detect that a DWARF section contribution is using the 64-bit
 format and to adapt its processing accordingly.}
 
 \needlines{4}
-\item Section offset and section length
-\hypertarget{datarep:sectionoffsetlength}{} 
+\item \hypertarget{datarep:sectionoffsetlength}{}
+Section offset and section length
 \addtoindexx{section length!use in headers}
 fields that occur
 \addtoindexx{section offset!use in headers}
@@ -1693,10 +1696,12 @@ constant data forms for one-, two-, four-, eight- and sixteen-byte values
 \DWFORMdatafourTARG,
 \DWFORMdataeightTARG{} and
 \DWFORMdatasixteenTARG). 
-There are also variable length constant
-data forms encoded using LEB128 numbers (see below). 
-Both signed (\DWFORMsdataTARG) and unsigned 
-(\DWFORMudataTARG) variable length constants are available.
+There are variable length constant
+data forms encoded using 
+\bb
+signed LEB128 numbers (\DWFORMsdataTARG) and unsigned 
+LEB128 numbers (\DWFORMudataTARG).
+\eb
 There is also an implicit constant (\DWFORMimplicitconst),
 whose value is provided as part of the abbreviation
 declaration.
@@ -1744,7 +1749,7 @@ is represented explicitly as a single byte of data
 implicitly (\DWFORMflagpresentTARG). 
 In the
 first case, if the \nolink{flag} has value zero, it indicates the
-absence of the attribute; if the \nolink{flag} has a non\dash zero value,
+absence of the attribute; if the \nolink{flag} has a non-zero value,
 it indicates the presence of the attribute. In the second
 case, the attribute is implicitly indicated as present, and
 no value is encoded in the debugging information entry itself.
@@ -1815,7 +1820,7 @@ offset into the \dotdebugranges{} section
 It consists of an
 offset from the beginning of the 
 \dotdebugranges{} section
-to the beginning of the non\dash contiguous address ranges
+to the beginning of the non-contiguous address ranges
 information for the referencing entity.  
 It is relocatable in
 a relocatable object file, and relocated in an executable or
@@ -2392,9 +2397,8 @@ Table \refersec{tab:locationlistentryencodingvalues}.
 \section{Base Type Attribute Encodings}
 \label{datarep:basetypeattributeencodings}
 
-The encodings of the 
-\hypertarget{chap:DWATencodingencodingofbasetype}{}
-constants used in the 
+The\hypertarget{chap:DWATencodingencodingofbasetype}{}
+encodings of the constants used in the 
 \DWATencodingDEFN{} attribute\addtoindexx{encoding attribute} 
 are given in 
 Table \refersec{tab:basetypeencodingvalues}
@@ -2620,7 +2624,10 @@ defined language.
 \DWLANGCeightynine &0x0001 &0 \addtoindexx{C:1989 (ISO)}      \\
 \DWLANGC{} &0x0002 &0  \addtoindexx{C!non-standard} \\
 \DWLANGAdaeightythree{} \dag &0x0003 &1  \addtoindexx{Ada:1983 (ISO)}     \\
-\DWLANGCplusplus{} &0x0004 &0 \addtoindexx{C++:1998 (ISO)}      \\
+\bb
+\DWLANGCplusplus{} &0x0004 &0 \addtoindexx{C++98 (ISO)} 
+\eb
+\\
 \DWLANGCobolseventyfour{} \dag &0x0005 &1 \addtoindexx{COBOL:1974 (ISO)}      \\
 \DWLANGCoboleightyfive{} \dag &0x0006 &1 \addtoindexx{COBOL:1985 (ISO)}      \\
 \DWLANGFortranseventyseven &0x0007 &1 \addtoindexx{FORTRAN:1977 (ISO)}      \\
@@ -2641,15 +2648,21 @@ defined language.
 \DWLANGGo{} \dag \ddag &0x0016 &0 \addtoindexx{Go}\\
 \DWLANGModulathree{} \dag \ddag &0x0017 &1 \addtoindexx{Modula-3}\\
 \DWLANGHaskell{} \dag \ddag &0x0018 &0 \addtoindexx{Haskell}\\
-\DWLANGCpluspluszerothree{} \ddag &0x0019 &0 \addtoindexx{C++:2003 (ISO)}\\
-\DWLANGCpluspluseleven{} \ddag &0x001a &0 \addtoindexx{C++:2011 (ISO)}\\
+\bb
+\DWLANGCpluspluszerothree{} \ddag &0x0019 &0 \addtoindexx{C++03 (ISO)}\\
+\DWLANGCpluspluseleven{} \ddag &0x001a &0 \addtoindexx{C++11 (ISO)}
+\eb
+\\
 \DWLANGOCaml{} \ddag &0x001b &0        \addtoindexx{OCaml}\\
 \DWLANGRust{} \ddag &0x001c &0 \addtoindexx{Rust}\\
 \DWLANGCeleven{} \ddag &0x001d &0 \addtoindexx{C:2011 (ISO)}\\
 \DWLANGSwift{} \ddag &0x001e &0 \addtoindexx{Swift} \\
 \DWLANGJulia{} \ddag &0x001f &1 \addtoindexx{Julia} \\
 \DWLANGDylan{} \ddag &0x0020 &0 \addtoindexx{Dylan} \\
-\DWLANGCplusplusfourteen{}~\ddag &0x0021 &0 \addtoindexx{C++:2014 (ISO)}     \\
+\bb
+\DWLANGCplusplusfourteen{}~\ddag &0x0021 &0 \addtoindexx{C++14 (ISO)} 
+\eb
+\\
 \DWLANGFortranzerothree{}~\ddag  &0x0022 &1 \addtoindexx{Fortran:2004 (ISO)} \\
 \DWLANGFortranzeroeight{}~\ddag  &0x0023 &1 \addtoindexx{Fortran:2010 (ISO)} \\
 \DWLANGlouser{} &0x8000 & \\
index 5cb951a..f6c0877 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}{August 28, 2015}
+\newcommand{\docdate}{October 18, 2015}
 %
 \usepackage{ifthen}
     \newcommand{\ifthen}[2]{\ifthenelse{#1}{#2}{}}
@@ -216,7 +216,8 @@ escapeinside={\%*}{*)}     % if you want to add a comment within your code
 % Preferred changebar asliases
 \newcommand{\bb}{\cbstart}      % Begin (change) bar
 \newcommand{\eb}{\cbend}        % End (change) bar
-\newcommand{\bbpareb}{\bb~\eb\vspace{-1.5\baselineskip}} % Mark deleted paragraph
+\newcommand{\bbeb}{\bb\eb}      % Mark deleted word or phrase
+\newcommand{\bbpareb}{\vspace{-0.6\baselineskip}\bb~\eb\vspace{-0.6\baselineskip}} % Mark deleted paragraph
 
 % Define commands for all of the DWARF names (DW\_*, .debug_*, a few others)
 %
@@ -340,7 +341,7 @@ escapeinside={\%*}{*)}     % if you want to add a comment within your code
 \uselinenos\include{generaldescription}        %\emptypage
 \uselinenos\include{programscope}              \emptypage
 \uselinenos\include{dataobject}                %\emptypage
-\uselinenos\include{typeentries}               %\emptypage
+\uselinenos\include{typeentries}               \emptypage
 \uselinenos\include{otherdebugginginformation} \emptypage
 \uselinenos\include{datarepresentation}        %\emptypage
 
index 0b16085..e3268bb 100644 (file)
@@ -2307,7 +2307,7 @@ The approaches are:
 \item  Inline both \texttt{OUTER} and \texttt{INNER} in all cases
 
 \item Inline \texttt{OUTER}, multiple \texttt{INNER}s \\
-Treat \texttt{INNER} as a non\dash inlinable part of \texttt{OUTER}, compile and
+Treat \texttt{INNER} as a non-inlinable part of \texttt{OUTER}, compile and
 call a distinct normal version of \texttt{INNER} defined within each
 inlining of \texttt{OUTER}.
 
index 65f4e80..bd3b534 100644 (file)
@@ -155,7 +155,11 @@ The attributes are listed in Table \referfol{tab:attributenames}.
 \addtoindexx{attributes!list of}
 \begin{longtable}{P{6.2cm}|P{8.5cm}}
   \caption{Attribute names} \label{tab:attributenames} \\
-  \hline \bfseries Attribute$^*$&\bfseries Identifies or Specifies \\ \hline
+  \hline \bfseries Attribute$^*$&\bfseries 
+\bb 
+Usage 
+\eb 
+\\ \hline
 \endfirsthead
   \bfseries Attribute$^*$&\bfseries Identifies or Specifies \\ \hline
 \endhead
@@ -182,12 +186,16 @@ The attributes are listed in Table \referfol{tab:attributenames}.
         {Out-of-line instances of inline subprograms}
         {out-of-line instances of inline subprograms} \\
 \DWATaccessibilityTARG
-&\livelink{chap:DWATaccessibilitycandadadeclarations}
-        {Accessibility of declarations} (\addtoindex{C++}, \addtoindex{Ada}) \\
-&\livelink{chap:DWATaccessibilitycppbaseclasses}
-        {Accessibility of base classes} (\addtoindex{C++}) \\
+\bb
+&\livelink{chap:DWATaccessdeclaration}
+        {Access declaration} (\addtoindex{C++}, \addtoindex{Ada}) \\
 &\livelink{chap:DWATaccessibilitycppinheritedmembers}
-        {Accessibility of inherited members} (\addtoindex{C++}) \\
+        {Accessibility of base or inherited class} (\addtoindex{C++}) \\
+&\livelinki{chap:DWATaccessibilityattribute}
+        {Accessibility of data member or member function}
+        {accessibility attribute} 
+\eb
+        \\
 \DWATaddressclassTARG
 &\livelinki{chap:DWATadressclasspointerorreferencetypes}
         {Pointer or reference types}
@@ -276,6 +284,10 @@ The attributes are listed in Table \referfol{tab:attributenames}.
 &\livelinki{chap:DWATcallcolumncolumnpositionofinlinedsubroutinecall}
            {Column position of inlined subroutine call}
            {column position of inlined subroutine call} \\
+&\livelinki{chap:DWATcallcolumnofcallsite}
+           {Column position of call site of non-inlined call} 
+           {column position of call site of non-inlined call}
+\bbeb          \\
 \DWATcalldatalocationTARG{}
 &\livelinki{chap:DWATcalldatalocationofcallparameter}
            {Address of the value pointed to by an argument passed in a call}
@@ -289,11 +301,19 @@ The attributes are listed in Table \referfol{tab:attributenames}.
 \DWATcallfileTARG
 &\livelinki{chap:DWATcallfilefilecontaininginlinedsubroutinecall}
            {File containing inlined subroutine call}
-           {file containing inlined subroutine call} \\
+           {file containing inlined subroutine call} 
+\bbeb          \\
+&\livelinki{chap:DWATcallfileofcallsite}
+           {File containing call site of non-inlined call} 
+           {file containing call site of non-inlined call} 
+\bbeb           \\
 \DWATcalllineTARG{} 
 &\livelinki{chap:DWATcalllinelinenumberofinlinedsubroutinecall}
            {Line number of inlined subroutine call}
            {line number of inlined subroutine call} \\
+&\livelinki{chap:DWATcalllineofcallsite}
+           {Line containing call site of non-inlined call} 
+           {line containing call site of non-inlined call} \\
 \DWATcallingconventionTARG{} 
 &\livelinki{chap:DWATcallingconventionforsubprograms}
            {Calling convention for subprograms}
@@ -556,7 +576,10 @@ The attributes are listed in Table \referfol{tab:attributenames}.
 \DWATlowpcTARG
 &\livelinki{chap:DWATlowpccodeaddressorrangeofaddresses}
         {Code address or range of addresses}
-        {code address or range of addresses}\\
+        {code address or range of addresses}\\*
+&\livelinki{chap:DWATlowpcbaseaddressofscope}
+        {Base address of scope}
+        {base address of scope}\\
 \DWATlowerboundTARG
 &\livelinki{chap:DWATlowerboundlowerboundofsubrange}
         {Lower bound of subrange}
@@ -715,7 +738,7 @@ The attributes are listed in Table \referfol{tab:attributenames}.
 &\livelinki{chap:DWATtypeofcallsite}
         {Type of call site}
         {type!of call site} \\
-&\livelinki{char:DWAATtypeofstringtype}
+&\livelinki{chap:DWAATtypeofstringtype}
         {Type of string type components}
         {type!of string type components} \\
 &\livelinki{chap:DWATtypetypeofsubroutinereturn}
@@ -741,15 +764,12 @@ The attributes are listed in Table \referfol{tab:attributenames}.
         {Non-constant parameter flag}
         {non-constant parameter flag}  \\
 \DWATvirtualityTARG
+\bb
 &\livelinki{chap:DWATvirtualityvirtualityindication}
-        {Virtuality indication}
-        {virtuality indication} \\
-&\livelinki{chap:DWATvirtualityvirtualityofbaseclass}
-        {Virtuality of base class}
-        {virtuality of base class} \\
-&\livelinki{chap:DWATvirtualityvirtualityoffunction}
-        {Virtuality of function}
-        {virtuality of function} \\
+        {virtuality attribute} 
+        {Virtuality of member function or base class}
+\eb
+        \\
 \DWATvisibilityTARG
 &\livelinki{chap:DWATvisibilityvisibilityofdeclaration}
         {Visibility of declaration}
@@ -1017,8 +1037,8 @@ children are represented as siblings of the first child.
 A chain of sibling entries is terminated by a null entry.
 
 In cases where a producer of debugging information feels that
-\hypertarget{chap:DWATsiblingdebugginginformationentryrelationship}{}
-it will be important for consumers of that information to
+it\hypertarget{chap:DWATsiblingdebugginginformationentryrelationship}{}
+will be important for consumers of that information to
 quickly scan chains of sibling entries, while ignoring the
 children of individual siblings, that producer may attach a
 \addtoindexx{sibling attribute}
@@ -1036,6 +1056,13 @@ of the entry to which the attribute is attached.
 \addtoindexx{size of an address|see{\textit{also} \texttt{address\_size}}}
 \addtoindexx{address size|see{size of an address}}
 \addtoindexx{address size|see{\textit{also} \texttt{address\_size}}}
+
+\bb
+Addresses, bytes and bits in DWARF use the numbering and direction
+conventions that are appropriate to the current language on
+the target system.
+\eb
+
 Many places in this document refer to the size of an address
 on the target architecture (or equivalently, target machine)
 to which a DWARF description applies. For processors which
@@ -1057,7 +1084,7 @@ object file will use the same address size.}
 
 \bbpareb
 
-\needlines{4}
+\needlines{6}
 \section{DWARF Expressions}
 \label{chap:dwarfexpressions}
 DWARF expressions describe how to compute a value or 
@@ -2380,14 +2407,12 @@ the accessibility of an object or of some other program
 entity. The accessibility specifies which classes of other
 program objects are permitted access to the object in question.}
 
-The accessibility of a declaration is 
-\hypertarget{chap:DWATaccessibilitycandadadeclarations}{}
+The accessibility of a declaration 
+is\hypertarget{chap:DWATaccessibilityattribute}{}
 represented by a 
-\DWATaccessibilityDEFN{} 
-attribute, whose
-\addtoindexx{accessibility attribute}
-value is a constant drawn from the set of codes listed in Table 
-\refersec{tab:accessibilitycodes}.
+\DWATaccessibilityDEFN{}\addtoindexx{accessibility attribute} 
+attribute, whose value is a constant drawn from the set of codes 
+listed in Table \refersec{tab:accessibilitycodes}.
 
 \begin{simplenametable}[1.9in]{Accessibility codes}{tab:accessibilitycodes}
 \DWACCESSpublicTARG{}          \\
@@ -2405,8 +2430,7 @@ visibility specifies which declarations are to be
 visible outside of the entity in which they are
 declared.}
 
-The 
-\hypertarget{chap:DWATvisibilityvisibilityofdeclaration}{}
+The\hypertarget{chap:DWATvisibilityvisibilityofdeclaration}{}
 visibility of a declaration is represented 
 by a \DWATvisibilityDEFN{}
 attribute\addtoindexx{visibility attribute}, whose value is a
@@ -2425,8 +2449,7 @@ Table \refersec{tab:visibilitycodes}.
 \textit{\addtoindex{C++} provides for virtual and pure virtual structure or class
 member functions and for virtual base classes.}
 
-The 
-\hypertarget{chap:DWATvirtualityvirtualityindication}{}
+The\hypertarget{chap:DWATvirtualityvirtualityindication}{}
 virtuality of a declaration is represented by a
 \DWATvirtualityDEFN{}
 attribute\addtoindexx{virtuality attribute}, whose value is a constant drawn
@@ -2453,8 +2476,8 @@ to non-static member functions.}
 Any debugging information entry representing the
 \addtoindexx{artificial attribute}
 declaration of an object or type artificially generated by
-a compiler and not explicitly declared by the source program
-\hypertarget{chap:DWATartificialobjectsortypesthat}{}
+a compiler and not explicitly declared by the source 
+program\hypertarget{chap:DWATartificialobjectsortypesthat}{}
 may have a 
 \DWATartificialDEFN{} attribute, 
 which is a \livelink{chap:classflag}{flag}.
@@ -2472,8 +2495,8 @@ rather than as locations within a single flat
 address space.}
 
 Any debugging information entry that contains a description
-\hypertarget{chap:DWATsegmentaddressinginformation}{}
-of the location of an object or subroutine may have a 
+of\hypertarget{chap:DWATsegmentaddressinginformation}{}
+the location of an object or subroutine may have a 
 \DWATsegmentDEFN{} attribute, 
 \addtoindexx{segment attribute}
 whose value is a location
@@ -2557,8 +2580,8 @@ entity. In certain contexts, however, a debugger might need
 information about a declaration of an entity that is not
 \addtoindexx{incomplete declaration}
 also a definition, or is otherwise incomplete, to evaluate
-\hypertarget{chap:DWATdeclarationincompletenondefiningorseparateentitydeclaration}{}
-an expression correctly.
+an\hypertarget{chap:DWATdeclarationincompletenondefiningorseparateentitydeclaration}{}
+expression correctly.
 
 \needlines{10}
 \textit{As an example, consider the following fragment of \addtoindex{C} code:}
@@ -2592,9 +2615,17 @@ of a program entity has a
 \DWATdeclarationDEFN{} attribute, which is a 
 \livelink{chap:classflag}{flag}.
 
+\textit{
+\bb
+A non-defining type declaration may nonetheless have 
+children as illustrated in Section
+\refersec{app:declarationscompletingnondefiningdeclarations}.
+\eb
+}
+
 \subsection{Declarations Completing Non-Defining Declarations}
-A debugging information entry that represents a 
-declaration\hypertarget{chap:DWATspecificationincompletenondefiningorseparatedeclaration}{}
+\hypertarget{chap:DWATspecificationincompletenondefiningorseparatedeclaration}{}
+A debugging information entry that represents a declaration
 that completes another (earlier) non-defining declaration may have a 
 \DWATspecificationDEFN{}
 attribute whose value is a \livelink{chap:classreference}{reference} to
@@ -2639,16 +2670,14 @@ entry.
 \textit{It is sometimes useful in a debugger to be able to associate
 a declaration with its occurrence in the program source.}
 
-Any debugging information 
-\hypertarget{chap:DWATdeclfilefilecontainingsourcedeclaration}{}
-entry 
-\hypertarget{chap:DWATdecllinelinenumberofsourcedeclaration}{}
-representing 
-\hypertarget{chap:DWATdeclcolumncolumnpositionofsourcedeclaration}{}
+Any debugging information entry representing 
 the declaration of an object, module, subprogram or type may have
-\DWATdeclfileDEFN,\addtoindexx{declaration file attribute} 
-\DWATdecllineDEFN\addtoindexx{declaration line attribute} and 
-\DWATdeclcolumnDEFN\addtoindexx{declaration column attribute}
+\DWATdeclfileDEFN,\hypertarget{chap:DWATdeclfilefilecontainingsourcedeclaration}{}
+\addtoindexx{declaration file attribute} 
+\DWATdecllineDEFN\hypertarget{chap:DWATdecllinelinenumberofsourcedeclaration}{}
+\addtoindexx{declaration line attribute} and 
+\DWATdeclcolumnDEFN\hypertarget{chap:DWATdeclcolumncolumnpositionofsourcedeclaration}{}
+\addtoindexx{declaration column attribute}
 attributes, each of whose value is an unsigned
 \livelink{chap:classconstant}{integer constant}.
 
@@ -2693,8 +2722,9 @@ attribute\addtoindexx{name attribute}, whose value of
 \bb
 class 
 \eb
-\CLASSstring{} represents the name as it appears in
-the source program. A debugging information entry containing
+\CLASSstring{} represents the name.
+\bbeb
+A debugging information entry containing
 no name attribute, or containing a name attribute whose value
 consists of a name containing a single null byte, represents
 a program entity for which no name was given in the source.
@@ -2715,14 +2745,11 @@ Section \referfol{chap:linkagenames} regarding the use of
 Sequences of multiple whitespace characters may be compressed.}
 
 \section{Data Locations and DWARF Procedures}
-Any debugging information entry describing a data object (which
 \hypertarget{chap:DWATlocationdataobjectlocation}{}
+Any debugging information entry describing a data object (which
 includes variables and parameters) or 
 \livelink{chap:commonblockentry}{common blocks}
-may have 
-\addtoindexx{location attribute}
-a
-\DWATlocationDEFN{} attribute,
+may have a \DWATlocationDEFN{} attribute,
 \addtoindexx{location attribute}
 whose value is a location description
 (see Section \refersec{chap:locationdescriptions}).
@@ -2769,23 +2796,17 @@ lexical
 try/catch \nolink{blocks} (see Section \refersec{chap:tryandcatchblockentries}), 
 labels and the like, may have
 \begin{itemize}
-\item A \DWATlowpcDEFN{} attribute for
-\hypertarget{chap:DWATlowpccodeaddressorrangeofaddresses}{}
-a single address,
+\item \hypertarget{chap:DWATlowpccodeaddressorrangeofaddresses}{}
+A \DWATlowpcDEFN{} attribute for a single address,
 
-\item A \DWATlowpcDEFN{}
-\addtoindexx{low PC attribute}
-and 
-\DWAThighpcDEFN{}
-\addtoindexx{high PC attribute}
-\hypertarget{chap:DWAThighpccontiguousrangeofcodeaddresses}{}
-pair of attributes for 
-a single contiguous range of
+\item \hypertarget{chap:DWAThighpccontiguousrangeofcodeaddresses}{}
+A \DWATlowpcDEFN{}\addtoindexx{low PC attribute}
+and \DWAThighpcDEFN{}\addtoindexx{high PC attribute}
+pair of attributes for a single contiguous range of
 addresses, or
 
-\item A \DWATrangesDEFN{} attribute 
-\addtoindexx{ranges attribute}
-\hypertarget{chap:DWATrangesnoncontiguousrangeofcodeaddresses}{}
+\item \hypertarget{chap:DWATrangesnoncontiguousrangeofcodeaddresses}{}
+A \DWATrangesDEFN{} attribute\addtoindexx{ranges attribute}
 for a non-contiguous range of addresses.
 \end{itemize}
 
@@ -2796,9 +2817,9 @@ none of these attributes are specified.
 
 \bb
 The \definitionx{base address} of the scope for any of the
-debugging information entries listed above is given 
-by either the \DWATlowpcNAME{} attribute or the first address
-in the first range entry 
+debugging information entries listed above is given by either the 
+\DWATlowpcNAME{}\livetargi{chap:DWATlowpcbaseaddressofscope}{}{base address of scope} 
+attribute or the first address in the first range entry 
 in the list of ranges given by the \DWATrangesNAME{} attribute.
 If there is no such attribute, the base address is undefined.
 \eb
@@ -2834,12 +2855,7 @@ instruction associated with the entity.
 \textit{The high PC value
 may be beyond the last valid instruction in the executable.}
 
-\needlines{5}
-The presence of low and high PC attributes for an entity
-implies that the code generated for the entity is contiguous
-and exists totally within the boundaries specified by those
-two attributes.
-\bb\eb
+\bbpareb
 
 \subsection{Non-Contiguous Address Ranges}
 \label{chap:noncontiguousaddressranges}
@@ -2882,9 +2898,12 @@ relative to that base.
 \bbpareb
 
 The \definitionx{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 is determined by the closest preceding base address 
+selection entry in the same range list (see
+\bb
+Section \refersec{chap:baseaddressselectionentry}). 
+\eb
+ 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:fullandpartialcompilationunitentries}).
@@ -2931,6 +2950,7 @@ range covered by such an entry is zero.}
 
 \needlines{5}
 \subsubsection{Base Address Selection Entry}
+\label{chap:baseaddressselectionentry}
 A \addtoindex{base address selection entry} consists of:
 \begin{enumerate}[1. ]
 \item The value of the largest representable address offset 
@@ -2987,8 +3007,7 @@ to indicate the
 \definitionx{entry address} which is the address of the 
 instruction where execution should begin
 \eb
-within that 
-range\hypertarget{chap:entryaddressofscope}{}
+within that range\hypertarget{chap:entryaddressofscope}{}
 of addresses. 
 \bb
 If the value of the \DWATentrypcNAME{} attribute is of
@@ -3032,7 +3051,8 @@ debugging information entry.  This entry may:
 \item describe a variable which contains the attribute value, or
 \item 
 \bb
-      contain a \DWATlocation{} attribute whose value is a \eb
+      contain a \DWATlocation{} attribute whose value is a
+\eb
       DWARF expression which computes the attribute value
       (for example, \bb\eb a \DWTAGdwarfprocedure{} entry).
 \end{itemize}
@@ -3057,9 +3077,8 @@ type descriptions of the form \texttt{typename\textquoteright Class}, and
 \doublequote{\texttt{access} typename} parameters.}
 
 Generally, any debugging information entry that 
-\hypertarget{chap:DWATdescriptionartificialnameordescription}{}
-has, or may have, a \DWATname{} attribute, may
-also have a
+has,\hypertarget{chap:DWATdescriptionartificialnameordescription}{}
+or may have, a \DWATname{} attribute, may also have a
 \addtoindexx{description attribute}
 \DWATdescriptionDEFN{} attribute whose value is a
 null-terminated string providing a description of the entity.
@@ -3153,8 +3172,9 @@ source program.
 A type or value parameter entry may have a \DWATname{} attribute, 
 \addtoindexx{name attribute}
 whose value is a
-null\dash terminated string containing the name of the corresponding 
-formal parameter as it appears in the source program.
+null-terminated string containing the name of the corresponding 
+formal parameter.
+\bbeb
 The entry may also have a 
 \DWATdefaultvalue{} attribute, which is a flag indicating 
 that the value corresponds to the default argument for the 
index 86e9c86..7f4d113 100644 (file)
@@ -500,7 +500,8 @@ Figure~\ref{fig:nameindexlayoutpart1}: Name Index Layout \textit{(concluded)}
 \end{figure}
 
 The formats of the header and the hash lookup table are described
-below, in Section \refersec{chap:datarepresentationofthenameindex}.
+\bbeb
+in Section \refersec{chap:datarepresentationofthenameindex}.
 
 The list of CUs and the list of local TUs are each an array of
 offsets, each of which is the offset of a compile unit or a type unit
@@ -637,7 +638,10 @@ declaration of that type.}
 \subsubsection{Data Representation of the Name Index}
 \label{chap:datarepresentationofthenameindex}
 The name index is placed in a section named \dotdebugnames, and
-consists of the eight parts described below.
+consists of the eight parts described
+\bb
+in the following sections.
+\eb
 
 \subsubsubsection{Section Header}
 The section header contains the following fields:
@@ -904,7 +908,7 @@ This header is followed by a variable number of address range
 descriptors. Each descriptor is a triple consisting of a
 segment selector, the beginning address within that segment
 of a range of text or data covered by some entry owned by
-the corresponding compilation unit, followed by the non\dash zero
+the corresponding compilation unit, followed by the non-zero
 length of that range. A particular set is terminated by an
 entry consisting of three zeroes. 
 When the \HFNsegmentselectorsize{} value
@@ -1040,7 +1044,7 @@ generated by the compiler. \\
 
 \addttindex{op\_index} &
 An unsigned integer representing the index of an operation within a VLIW
-instruction. The index of the first operation is 0. For non\dash VLIW
+instruction. The index of the first operation is 0. For non-VLIW
 architectures, this register will always be 0.  \\
 
 \addttindex{file} &
@@ -1150,10 +1154,14 @@ These have a \HFTubyte{} opcode field and no operands.\vspace{1ex}
 \textit{Most of the instructions in a 
 line number program are special opcodes.}
 
+\needlines{6}
 \item standard opcodes \\
 These have a \HFTubyte{} opcode field which may be followed by zero or more
 \addtoindex{LEB128} operands (except for 
-\mbox{\DWLNSfixedadvancepc,} see below).
+\mbox{\DWLNSfixedadvancepc,} see 
+\bb
+Section \refersec{chap:standardopcodes}).
+\eb
 The opcode implies the number of operands and their meanings, but the
 line number program header also specifies the number of operands for
 each standard opcode.
@@ -1366,7 +1374,12 @@ goals:}
     Each description consists of a pair of ULEB128 values:
 \begin{itemize}
 \setlength{\itemsep}{0em}
-\item A content type code (see below)
+\item A content type code (see 
+\bb
+Sections \refersec{chap:standardcontentdescriptions} and
+\refersec{chap:vendordefinedcontentdescriptions}).
+\eb
+
 \item A form code using the attribute form codes
 \end{itemize}
 
@@ -1466,6 +1479,7 @@ share a single copy of the current file name string.}
 \end{enumerate}
 
 \subsubsection{Standard Content Descriptions}
+\label{chap:standardcontentdescriptions}
 DWARF-defined content type codes are used to indicate
 the type of information that is represented in one
 component of an include directory or file name description.
@@ -1537,6 +1551,7 @@ of the file contents. It is paired with form \DWFORMdatasixteen.
 is found in Appendix \refersec{app:linenumberheaderexample}.}
 
 \subsubsection{Vendor-defined Content Descriptions}
+\label{chap:vendordefinedcontentdescriptions}
 Vendor-defined content descriptions may be defined using content
 type codes in the range \DWLNCTlouserTARG{} to \DWLNCThiuserTARG{}. Each
 such code may be combined with one or more forms from the set:
@@ -1552,7 +1567,7 @@ it were not present.
 
 \needlines{6}
 \subsection{The Line Number Program}
-\label{linenumberprogram}
+\label{chap:linenumberprogram}
 As stated before, the goal of a line number program is to build
 a matrix representing one compilation unit, which may have
 produced multiple sequences of target machine instructions.
@@ -1745,8 +1760,6 @@ takes no operands.
 It sets the \addttindex{basic\_block} register of the
 state machine to \doublequote{true.}
 
-
-
 \item \textbf{\DWLNSconstaddpcTARG} \\
 The \DWLNSconstaddpcNAME{} opcode takes
 no operands. It advances the \texttt{address} and \addttindex{op\_index} registers
@@ -2063,7 +2076,7 @@ The contents of the operands are described below (see Sections
 \end{enumerate}
 
 \subsubsection{Macro Source Line Number}
-\label{char:macrosourcelinenumber}
+\label{chap:macrosourcelinenumber}
 In all define and undefine macro information entries,
 as well as the \DWMACROstartfile{} entry,
 the line number of the entry occurs is encoded as an
@@ -2150,7 +2163,7 @@ ending of an included file.
 A \DWMACROstartfileNAME{} entry has two operands. The
 first operand encodes the line number of the source line on
 which the \texttt{\#include} macro directive occur
-(see Section \refersec{char:macrosourcelinenumber}).
+(see Section \refersec{chap:macrosourcelinenumber}).
 The second operand encodes a source file name index. 
 
 The source file name index is the file number in the 
@@ -2505,7 +2518,10 @@ A
 constant that is factored out of all advance location
 instructions (see 
 Section \refersec{chap:rowcreationinstructions}).
-
+\bb
+The resulting value is  
+\mbox{\textit{(operand} * \HFNcodealignmentfactor)}.
+\eb
 
 \item  \HFNdataalignmentfactor{} (signed LEB128)
 \addtoindexx{LEB128!signed}\addtoindexx{signed LEB128|see{LEB128, signed}} \\
@@ -2513,7 +2529,12 @@ Section \refersec{chap:rowcreationinstructions}).
 A 
 \addtoindexx{\textless daf\textgreater|see{data alignment factor}}
 constant that is factored out of certain offset instructions
-(see below). The resulting value is  \textit{(operand} *
+(see 
+\bb
+Sections \refersec{chap:cfadefinitioninstructions} and 
+\refersec{chap:registerruleinstructions}).
+\eb
+The resulting value is  \textit{(operand} *
 \HFNdataalignmentfactor).
 
 \item  \HFNreturnaddressregister{} (unsigned LEB128)\addtoindexx{LEB128!unsigned} \\
@@ -2572,12 +2593,15 @@ The number
 of bytes of program instructions described by this entry.
 
 \item \HFNinstructions{} (array of \HFTubyte) \\
-A sequence of table defining instructions that are described below.
+A sequence of table defining instructions that are described 
+\bb
+in Section \refersec{chap:callframeinstructions}.
+\eb
 
 \needlines{4}
 \item \HFNpadding{} (array of \HFTubyte) \\
 Enough \DWCFAnop{} instructions 
-to make the size of this entry match the length value above.
+to make the size of this entry match the \HFNlength{} value above.
 \end{enumerate}
 
 \needlines{8}
@@ -2600,8 +2624,13 @@ operators cannot be used in such operands:
 
 
 \begin{itemize}
-\item \DWOPcalltwo, \DWOPcallfour{} 
-and \DWOPcallref{} operators are 
+\item
+\bb
+\DWOPaddrx, \DWOPcalltwo, \DWOPcallfour{}, \DWOPcallref, 
+\DWOPconsttype, \DWOPconstx, \DWOPconvert, \DWOPdereftype, 
+\DWOPregvaltype{} and \DWOPreinterpret{}
+\eb
+operators are 
 not allowed in an operand of these instructions because
 the call frame information must not depend on other
 debug sections.
@@ -2634,7 +2663,7 @@ current row. The new location value is always greater than
 the current one. 
 If the \HFNsegmentselectorsize{} field of this FDE's 
 \addtoindex{CIE}
-is non\dash zero, the initial location is preceded by a segment
+is non-zero, the initial location is preceded by a segment
 selector of the given length.
 
 \needlines{4}
@@ -2669,14 +2698,14 @@ and size of the delta operand.
 
 \end{enumerate}
 
-\label{chap:cfadefinitioninstructions}
 \subsubsection{CFA Definition Instructions}
+\label{chap:cfadefinitioninstructions}
 \begin{enumerate}[1. ]
 
 \item \textbf{\DWCFAdefcfaTARG} \\
 The \DWCFAdefcfaNAME{}
 instruction takes two unsigned LEB128\addtoindexx{LEB128!unsigned}
-operands representing a register number and a (non\dash factored)
+operands representing a register number and a (non-factored)
 offset. The required action is to define the current CFA rule
 to use the provided register and offset.
 
index d8c7b34..eba92d8 100644 (file)
@@ -9,7 +9,6 @@ these entries may be thought of as
 
 \section{Unit Entries}
 \label{chap:unitentries}
-
 A DWARF object file is an object file that contains one or more 
 DWARF compilation units, of which there are these kinds:
 \addtoindexx{unit|see {compilation unit}} 
@@ -123,14 +122,19 @@ are used to represent portions of an object file.
 data contributed to an executable by a single relocatable
 object file. It may be derived from several source 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
+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
 to save space. It may be derived from an \doublequote{include file,}
 template instantiation, or other implementation-dependent
 portion of a compilation. A full compilation unit can also
 function in a manner similar to a partial compilation unit
-in some cases.}
+in some cases.
+\bb 
+See Appendix \refersec{app:dwarfcompressionandduplicateeliminationinformative}
+for discussion of related compression techniques.
+\eb
+}
 
 A compilation unit entry owns debugging information
 entries that represent all or part of the declarations
@@ -156,9 +160,8 @@ a
 \addtoindexx{ranges attribute}
 whose values encode 
 \addtoindexx{discontiguous address ranges|see{non-contiguous address ranges}}
-the
-contiguous or 
-non\dash contiguous address ranges, respectively,
+the contiguous or 
+non-contiguous address ranges, respectively,
 of the machine instructions generated for the compilation
 unit (see Section \refersec{chap:codeaddressesandranges}).
   
@@ -175,19 +178,20 @@ location lists (see Section
 \addtoindexx{range list}
 (see Section \refersec{chap:noncontiguousaddressranges}).
 
-\item A \DWATnameDEFN{} attribute 
-\addtoindexx{name attribute}
+\item \hypertarget{chap:DWATnamepathnameofcompilationsource}{}
+A \DWATnameDEFN{} attribute \addtoindexx{name attribute}
 whose value is a null-terminated string 
-\hypertarget{chap:DWATnamepathnameofcompilationsource}{}
-containing the full or relative path name of the primary
+containing the full or relative path name 
+\bb
+(relative to the value of the \DWATcompdir{} attribute, 
+see below)
+\eb
+of the primary
 source file from which the compilation unit was derived.
 
-\item A \DWATlanguageDEFN{} attribute 
-\addtoindexx{language attribute}
-whose constant value is an
-\hypertarget{chap:DWATlanguageprogramminglanguage}{}
-integer code 
-\addtoindexx{language attribute}
+\item \hypertarget{chap:DWATlanguageprogramminglanguage}{}
+A \DWATlanguageDEFN{} attribute\addtoindexx{language attribute}
+whose constant value is an integer code 
 indicating the source language of the compilation
 unit. The set of language names and their meanings are given
 in Table \refersec{tab:languagenames}.
@@ -210,10 +214,13 @@ in Table \refersec{tab:languagenames}.
 \DWLANGCeightynineTARG & ISO C:1989 \addtoindexx{C:1989 (ISO)} \\
 \DWLANGCninetynineTARG & ISO C:1999 \addtoindexx{C:1999 (ISO)} \\
 \DWLANGCelevenTARG     & ISO C:2011 \addtoindexx{C:2011 (ISO)} \\
-\DWLANGCplusplusTARG          & ISO C++:1998 \addtoindexx{C++:1998 (ISO)} \\
-\DWLANGCpluspluszerothreeTARG & ISO C++:2003 \addtoindexx{C++:2003 (ISO)} \\
-\DWLANGCpluspluselevenTARG    & ISO C++:2011 \addtoindexx{C++:2011 (ISO)} \\
-\DWLANGCplusplusfourteenTARG  & ISO C++:2014 \addtoindexx{C++:2014 (ISO)} \\
+\bb
+\DWLANGCplusplusTARG          & ISO C++98 \addtoindexx{C++98 (ISO)} \\
+\DWLANGCpluspluszerothreeTARG & ISO C++03 \addtoindexx{C++03 (ISO)} \\
+\DWLANGCpluspluselevenTARG    & ISO C++11 \addtoindexx{C++11 (ISO)} \\
+\DWLANGCplusplusfourteenTARG  & ISO C++14 \addtoindexx{C++14 (ISO)} 
+\eb
+\\
 \DWLANGCobolseventyfourTARG & ISO COBOL:1974 \addtoindexx{COBOL:1974 (ISO)} \\
 \DWLANGCoboleightyfiveTARG  & ISO COBOL:1985 \addtoindexx{COBOL:1985 (ISO)} \\
 \DWLANGDTARG{}~\dag & D \addtoindexx{D language} \\
@@ -237,7 +244,10 @@ in Table \refersec{tab:languagenames}.
 \DWLANGPLITARG{}~\dag & ANSI PL/I:1976 \addtoindexx{PL/I:1976 (ANSI)} \\
 \DWLANGPythonTARG{}~\dag & \addtoindex{Python} \\
 \DWLANGRustTARG{}~\dag & \addtoindex{Rust} \\
-\DWLANGSwiftTARG{}~\dag & \addtoindex{Swift} \\
+\bb
+\DWLANGSwiftTARG{}
+\eb
+ & \addtoindex{Swift} \\
 \DWLANGUPCTARG{} & UPC (Unified Parallel C) \addtoindexx{UPC}  
                          \index{Unified Parallel C|see{UPC}} \\ 
 \hline
@@ -246,9 +256,8 @@ in Table \refersec{tab:languagenames}.
 \end{centering}
 
 \needlines{6}
-\item A \DWATstmtlistDEFN{}
-\hypertarget{chap:DWATstmtlistlinenumberinformationforunit}{}
-\addtoindexx{statement list attribute}
+\item \hypertarget{chap:DWATstmtlistlinenumberinformationforunit}{}
+A \DWATstmtlistDEFN{}\addtoindexx{statement list attribute}
 attribute whose value is a 
 \addtoindexx{section offset!in statement list attribute}
 section offset to the line number information for this compilation
@@ -285,19 +294,17 @@ or shared object file. The two attributes have distinct encodings to facilitate
 coexistence.}
 
 \needlines{6}
-\item  A 
-\DWATcompdirDEFN{} attribute\addtoindexx{compilation directory attribute} 
-\hypertarget{chap:DWATcompdircompilationdirectory}{}
+\item  \hypertarget{chap:DWATcompdircompilationdirectory}{}
+A \DWATcompdirDEFN{} attribute\addtoindexx{compilation directory attribute} 
 whose value is a
 null-terminated string containing the current working directory
 of the compilation command that produced this compilation
 unit in whatever form makes sense for the host system.
 
-\item  A \DWATproducerDEFN{} attribute 
-\addtoindexx{producer attribute}
+\item  \hypertarget{chap:DWATproducercompileridentification}{}
+A \DWATproducerDEFN{} attribute\addtoindexx{producer attribute}
 whose value is a null-terminated string containing 
 information about the compiler
-\hypertarget{chap:DWATproducercompileridentification}{}
 that produced the compilation unit. The actual contents of
 the string will be specific to each producer, but should
 begin with the name of the compiler vendor or some other
@@ -305,11 +312,9 @@ identifying character sequence that should avoid confusion
 with other producer values.
 
 \needlines{4}
-\item  A \DWATidentifiercaseDEFN{} 
-attribute 
-\addtoindexx{identifier case attribute}
-whose integer
-\hypertarget{chap:DWATidentifiercaseidentifiercaserule}{}
+\item  \hypertarget{chap:DWATidentifiercaseidentifiercaserule}{}
+A \DWATidentifiercaseDEFN{} attribute 
+\addtoindexx{identifier case attribute} whose integer
 constant value is a code describing the treatment
 of identifiers within this compilation unit. The
 set of identifier case codes is given in
@@ -356,12 +361,10 @@ program but that a case insensitive lookup should be used to
 access those names.
 
 \needlines{5}
-\item A \DWATbasetypesDEFN{} attribute whose value is a 
-\livelink{chap:classreference}{reference}. This 
-\hypertarget{chap:DWATbasetypesprimitivedatatypesofcompilationunit}{}
-attribute 
-\addtoindexx{base types attribute}
-points to a debugging information entry
+\item \hypertarget{chap:DWATbasetypesprimitivedatatypesofcompilationunit}{}
+A \DWATbasetypesDEFN{} attribute\addtoindexx{base types attribute} 
+whose value is a \livelink{chap:classreference}{reference}. 
+This attribute points to a debugging information entry
 representing another compilation unit.  It may be used
 to specify the compilation unit containing the base type
 entries used by entries in the current compilation unit
@@ -371,32 +374,34 @@ entries used by entries in the current compilation unit
 \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.}
+to interpret a type conversion to a base type correctly.}
 
-\item A \DWATuseUTFeightDEFN{} attribute,
+\item \hypertarget{chap:DWATuseUTF8compilationunitusesutf8strings}{}
+A \DWATuseUTFeightDEFN{} attribute,
 \addtoindexx{use UTF8 attribute}\addtoindexx{UTF-8} 
 which is a \livelink{chap:classflag}{flag} whose
 presence indicates that all strings (such as the names of
 declared entities in the source program, or filenames in the line number table) 
-are represented using the UTF\dash 8 representation. 
+are represented using the UTF-8 representation. 
 
 \needlines{4}
-\item A \DWATmainsubprogramDEFN{} attribute, which is a 
-\livelink{chap:classflag}{flag}
-\addtoindexx{main subprogram attribute}
-whose presence indicates 
-\hypertarget{chap:DWATmainsubprogramunitcontainingmainorstartingsubprogram}{}
-that the compilation unit contains a
-subprogram that has been identified as the starting function
+\item \hypertarget{chap:DWATmainsubprogramunitcontainingmainorstartingsubprogram}{}
+A \DWATmainsubprogramDEFN{} attribute,\addtoindexx{main subprogram attribute} 
+which is a \livelink{chap:classflag}{flag},
+whose presence indicates that the compilation unit contains a
+subprogram that has been identified as the starting
+\bb
+subprogram
+\eb
 of the program. If more than one compilation unit contains
-this \nolink{flag}, any one of them may contain the starting function.
+this \nolink{flag}, any one of them may contain the starting 
+\bb
+function.
+\eb
 
 \textit{\addtoindex{Fortran} has a \addtoindex{PROGRAM statement}
 which is used
-to specify and provide a user\dash specified name for the main
+to specify and provide a user-specified name for the main
 subroutine of a program. 
 \addtoindex{C} uses the name \doublequote{main} to identify
 the main subprogram of a program. Some other languages provide
@@ -405,16 +410,17 @@ a program. The \DWATmainsubprogram{} attribute may also be used to
 identify such subprograms (see 
 Section \refersec{chap:generalsubroutineandentrypointinformation}).}
 
-\item A \DWATentrypc{} attribute whose value is the address of the first
+\item 
 \hypertarget{chap:DWATentrypcofcompileunit}{}
 \hypertarget{chap:DWATentrypcofpartialunit}{}
+A \DWATentrypc{} attribute whose value is the address of the first
 \addtoindexx{entry pc attribute}
 executable instruction of the unit (see 
 Section \refersec{chap:entryaddress}).
 
 \needlines{8}
-\item A \DWATstroffsetsbaseDEFN\addtoindexx{string offset base attribute}
-\hypertarget{chap:DWATstroffsetbaseforindirectstringtable}{} 
+\item \hypertarget{chap:DWATstroffsetbaseforindirectstringtable}{}
+A \DWATstroffsetsbaseDEFN\addtoindexx{string offset base attribute}
 attribute, whose value is of class \CLASSstroffsetsptr. 
 This attribute points to the first string
 offset of the compilation unit's contribution to the
@@ -424,19 +430,20 @@ Indirect string references
 interpreted as indices relative to this base.
 
 \needlines{6}
-\item A \DWATaddrbaseDEFN\addtoindexx{address table base attribute}
-\hypertarget{chap:DWATaddrbaseforaddresstable}{}
+\item \hypertarget{chap:DWATaddrbaseforaddresstable}{}
+A \DWATaddrbaseDEFN\addtoindexx{address table base attribute}
 attribute, whose value is of class \CLASSaddrptr.
 This attribute points to the beginning of the compilation
 unit's contribution to the \dotdebugaddr{} section.
 Indirect references (using \DWFORMaddrx, \DWOPaddrx, 
 \DWOPconstx, \DWLLEbaseaddressselectionentry{}, 
-\DWLLEstartendentry, or \DWLLEstartlengthentry) within the compilation unit are
-interpreted as indices relative to this base.
+\DWLLEstartendentry{} or \DWLLEstartlengthentry) 
+within the compilation unit are interpreted as indices 
+relative to this base.
 
 \needlines{5}
-\item A \DWATrangesbaseDEFN\addtoindexx{ranges table base attribute}
-\hypertarget{chap:DWATrangesbaseforrangelists}{}
+\item \hypertarget{chap:DWATrangesbaseforrangelists}{}
+A \DWATrangesbaseDEFN\addtoindexx{ranges table base attribute}
 attribute, whose value is of class \CLASSrangelistptr.
 This attribute points to the beginning of the compilation
 unit's contribution to the \dotdebugranges{} section.
@@ -476,17 +483,20 @@ A skeleton compilation unit has \DWATdwoname{} and
 
 \begin{enumerate}[1. ]
 
-\item
-\livetarg{chap:DWATdwonameforunit}{}
+\item \livetarg{chap:DWATdwonameforunit}{}
 A \DWATdwonameDEFN{} attribute
 \addtoindexx{split DWARF object file name attribute}
 whose value is a
 null-terminated string containing the full or relative
-path name of the object file that contains the full
+path name 
+\bb
+(relative to the value of the \DWATcompdir{} attribute, 
+see below)
+\eb
+of the object file that contains the full
 compilation unit.
 
-\item
-\livetarg{chap:DWATdwoidforunit}{}
+\item \livetarg{chap:DWATdwoidforunit}{}
 A \DWATdwoidDEFN{} attribute\addtoindexx{unit identification attribute}
 whose implementation-defined integer constant value,
 known as the \CUsignature,
@@ -506,47 +516,57 @@ need to be similar or related to the means of determining a
 \end{enumerate}
 
 A skeleton compilation unit may have additional
-attributes from among the following:
+attributes, 
+\bb
+which are the same as for conventional compilation unit entries 
+except as noted,
+\eb
+from among the following:
 
 \begin{enumerate}[1. ]
 \addtocounter{enumi}{2}
 \item
 Either a \DWATlowpc{} and \DWAThighpc{} pair of attributes
-or a \DWATranges{} attribute (the same as for conventional
-compilation unit entries).
+or a \DWATranges{} attribute.
+\bb\eb
 
 \item
-A \DWATstmtlist{} attribute (the same as for conventional
-compilation unit entries).
+A \DWATstmtlist{} attribute.
+\bb\eb
 
 \item
-A \DWATcompdir{} attribute (the same as for conventional
-compilation unit entries).
+A \DWATcompdir{} attribute.
+\bb\eb 
 
 \needlines{6}
 \item
-A \DWATuseUTFeight{} attribute (the same as for conventional 
-compilation unit entries).
+A \DWATuseUTFeight{} attribute.
+\bb\eb 
 
 \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 object file referenced 
 by the \DWATdwoname{} attribute is determined by the presence 
-of a \DWATuseUTFeight{} attribute in the skeleton compilation unit.}
+of a \DWATuseUTFeight{} attribute in the
+\bb
+full compilation unit 
+(see Section \refersec{chap:splitfullcompilationunitentries}).
+\eb
+}
 
 \item
 A \DWATstroffsetsbase{} attribute, for indirect strings references 
-from the skeleton compilation unit (the same as for conventional 
-compilation unit entries).
+from the skeleton compilation unit.
+\bb\eb 
 
 \item
-A \DWATaddrbase{} attribute (the same as for conventional
-compilation unit entries).
+A \DWATaddrbase{} attribute.
+\bb\eb 
 
 \item
-A \DWATrangesbase{} attribute (the same as for conventional
-compilation unit entries).
+A \DWATrangesbase{} attribute.
+\bb\eb 
 
 \end{enumerate}
 
@@ -590,47 +610,57 @@ split compilation unit and the associated skeleton
 compilation unit must use the same form to encode the 
 identification value.
 
-\textit{The means of determining a \CUsignature{} does not 
-need to be similar or related to the means of determining a
-\TUsignature.}
+\bbpareb
 
 \end{enumerate}
 
+\needlines{4}
 A split full compilation unit may also have additional 
-attributes from among the following:
+attributes,
+\bb
+which are the same as for conventional compilation unit entries 
+except as noted,
+\eb
+from among the following:
 \begin{enumerate}[1. ]
 \addtocounter{enumi}{1}
-\item A \DWATname{} attribute (the same as for conventional 
-compilation unit entries).
+\item A \DWATname{} attribute.
+\bb\eb 
 
-\item A \DWATlanguage{} attribute (the same as for conventional 
-compilation unit entries)
+\item A \DWATlanguage{} attribute.
+\bb\eb 
         
-\item A \DWATmacros{} attribute (the same as for conventional 
-compilation unit entries).
-
-\textit{The offset in the value of class \CLASSmacptr{} is 
-relative to the \dotdebugmacrodwo{} section.}
+\item A \DWATmacros{} attribute.
+\bb 
+The value of this attribute is of class \CLASSmacptr{}, which is 
+an offset relative to the \dotdebugmacrodwo{} section.
+\eb
         
-\item A \DWATproducer{} attribute (the same as for conventional 
-compilation unit entries).
+\item A \DWATproducer{} attribute.
+\bb\eb 
         
-\item A \DWATidentifiercase{} attribute (the same as for 
-conventional compilation unit entries).
+\item A \DWATidentifiercase{} attribute.
+\bb\eb 
         
-\item A \DWATmainsubprogram{} attribute (the same as for 
-conventional compilation unit entries).
+\item A \DWATmainsubprogram{} attribute.
+\bb\eb 
+
+\item A \DWATentrypc{} attribute.
+\bb\eb 
+
+\item A
+\bb
+\DWATuseUTFeight{} attribute.
+\eb  
 
-\item A \DWATentrypc{} attribute (the same as for conventional 
-compilation unit entries).
-        
 \end{enumerate}
 
 \textit{The following attributes are not part of a 
 split full compilation unit entry but instead are inherited 
 (if present) from the corresponding skeleton compilation unit: 
 \DWATlowpc, \DWAThighpc, \DWATranges, \DWATstmtlist, \DWATcompdir, 
-\DWATuseUTFeight, \DWATstroffsetsbase, \DWATaddrbase{} and 
+\bb\eb
+\DWATstroffsetsbase, \DWATaddrbase{} and 
 \DWATrangesbase.}
 
 \textit{The \DWATbasetypes{} attribute is not defined for a
@@ -656,6 +686,10 @@ the sections in which they are represented
 (see \refersec{datarep:splitdwarfobjectfiles} for details).
 \addtoindexx{conventional type unit}
 \addtoindexx{split type unit}
+\bb
+Moreover, the \DWATstroffsetsbase{} attribute (see below) is not 
+used in a split type unit.
+\eb
 
 A type unit is represented by a debugging information entry
 with the tag \DWTAGtypeunitTARG. 
@@ -737,6 +771,14 @@ 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.
 
+\textit{
+\bb
+Examples of these kinds of relationships are found in
+Section \refersec{app:signaturecomputationexample} and
+Section \refersec{app:declarationscompletingnondefiningdeclarations}.
+\eb
+}
+
 \needlines{4}
 \textit{Types are not required to be placed in type units. In general,
 only large types such as structure, class, enumeration, and
@@ -779,7 +821,8 @@ If the module has a name, the module entry has a
 \DWATname{} attribute 
 \addtoindexx{name attribute}
 whose value is a null\dash terminated string containing
-the module name as it appears in the source program.
+the module name.
+\bbeb
 
 The \addtoindex{module entry} may have either a 
 \DWATlowpc{} and
@@ -791,14 +834,13 @@ of
 attributes or a 
 \DWATranges{} attribute
 \addtoindexx{ranges attribute}
-whose values encode the contiguous or non\dash contiguous address
+whose values encode the contiguous or non-contiguous address
 ranges, respectively, of the machine instructions generated for
-the module initialization code 
+the module initialization
+code\hypertarget{chap:DWATentrypcentryaddressofmoduleinitialization}{} 
 (see Section \refersec{chap:codeaddressesandranges}). 
-\hypertarget{chap:DWATentrypcentryaddressofmoduleinitialization}{}
-It may also
+It may also have a
 \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
 (see Section \refersec{chap:entryaddress}).
@@ -824,16 +866,10 @@ do not accidentally clash in the
 application is linked together.}
 
 A namespace is represented by a debugging information entry
-with the 
-tag \DWTAGnamespaceTARG. 
-A namespace extension is
-\hypertarget{chap:DWATextensionpreviousnamespaceextensionororiginalnamespace}{}
-represented by a 
-\DWTAGnamespaceNAME{} entry 
-with 
-\addtoindexx{extension attribute}
-a 
-\DWATextensionDEFN{}
+with the tag \DWTAGnamespaceTARG. A namespace extension 
+is\hypertarget{chap:DWATextensionpreviousnamespaceextensionororiginalnamespace}{}
+represented by a \DWTAGnamespaceNAME{} entry with a 
+\DWATextensionDEFN{}\addtoindexx{extension attribute}
 attribute referring to the previous extension, or if there
 is no previous extension, to the original 
 \DWTAGnamespaceNAME{}
@@ -854,16 +890,17 @@ other
 debugging information entries describing program entities
 whose declarations occur in the namespace.
 
-\textit{For \addtoindex{C++}, such 
-owned program entities may be declarations,
-including certain declarations that are also object or
-function definitions.}
+\bbpareb
 
 A namespace may have a 
 \DWATexportsymbolsDEFN{}\livetarg{chap:DWATexportsymbolsofnamespace}{}
 attribute\addtoindexx{export symbols attribute}
 \addtoindexx{inline namespace|see{\textit{also} export symbols attribute}}
-which indicates that all member names defined within the 
+which 
+\bb
+is a \CLASSflag{} which
+\eb
+indicates that all member names defined within the 
 namespace may be referenced as if they were defined within 
 the containing namespace. 
 
@@ -916,27 +953,21 @@ references in exactly the manner defined by the
 \addtoindex{C++} language.
 }
 
-\textit{Emitting all namespace declaration information in all
-compilation units can result in a significant increase in the
-size of the debug information and significant duplication of
-information across compilation units. 
-The \addtoindex{C++} namespace std,
-for example, 
-\addtoindexx{namespace (C++)!std}
-is large and will probably be referenced in
-every \addtoindex{C++} compilation unit.
-}
+\bbpareb
 
 \textit{For \addtoindex{C++} namespace examples, 
-see Appendix \refersec{app:namespaceexamples}.
-}
+see Appendix \refersec{app:namespaceexamples}.}
 
 
 \needlines{5}
 \subsection{Imported (or Renamed) Declaration Entries} 
 \label{chap:importedorrenameddeclarationentries}
 \textit{Some languages support the concept of importing into or making
-accessible in a given unit declarations made in a different
+accessible in a given unit 
+\bb
+certain declarations that occur
+\eb
+in a different
 module or scope. An imported declaration may sometimes be
 given another name.
 }
@@ -945,24 +976,21 @@ An imported declaration is represented by one or
 \addtoindexx{imported declaration entry}
 more debugging information entries with the 
 tag \DWTAGimporteddeclarationTARG. 
-When 
-\hypertarget{chap:DWATimportimporteddeclaration}{}
-an overloaded entity
-is imported, there is one imported declaration entry for
-each overloading. 
-\addtoindexx{import attribute}
+When\hypertarget{chap:DWATimportimporteddeclaration}{}
+an overloaded entity is imported, there is one imported 
+declaration entry for each overloading. 
 Each imported declaration entry has a
-\DWATimportDEFN{} attribute,
+\DWATimportDEFN{} attribute,\addtoindexx{import attribute}
 whose value is a \livelink{chap:classreference}{reference} to the
 debugging information entry representing the declaration that
 is being imported.
 
-An imported declaration may also have a 
-\DWATname{}
-attribute
-\addtoindexx{name attribute}
+An imported declaration may also have a \DWATname{}
+attribute\addtoindexx{name attribute}
 whose value is a null-terminated string containing the
-name, as it appears in the source program, by which the
+name
+\bbeb
+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
 the entity being imported). If no name is present, then the
@@ -975,22 +1003,20 @@ used as a general means to rename or provide an alias for
 an entity, regardless of the context in which the importing
 declaration or the imported entity occurs.
 
-\textit{A \addtoindex{C++} namespace alias may be represented 
-by an imported
-\hypertarget{chap:DWATimportnamespacealias}{}
-declaration entry 
+\textit{A \addtoindex{C++}
+namespace alias\hypertarget{chap:DWATimportnamespacealias}{} 
+may be represented by an imported declaration entry 
 \addtoindexx{namespace (C++)!alias}
 with a name attribute whose value is
-a null-terminated string containing the alias name as it
-appears in the source program and a \DWATimportDEFN{} attribute 
+a null-terminated string containing the alias name
+\bbeb 
+and a \DWATimportDEFN{} attribute 
 whose value is a \livelink{chap:classreference}{reference} to the 
-applicable original namespace or namespace extension entry.
-}
+applicable original namespace or namespace extension entry.}
 
 \textit{A \addtoindex{C++} using declaration may be represented 
 by one or more
-\hypertarget{chap:DWATimportnamespaceusingdeclaration}{}
-imported 
+imported\hypertarget{chap:DWATimportnamespaceusingdeclaration}{} 
 \addtoindexx{namespace (C++)!using declaration}
 declaration entries.  When the using declaration
 refers to an overloaded function, there is one imported
@@ -1049,8 +1075,8 @@ module entry by the same name as it is declared in the module.
 \textit{A \addtoindex{C++} using directive
 \addtoindexx{namespace (C++)!using directive}
 \addtoindexx{using directive|see {namespace (C++), using directive}} 
-may be represented by an imported module
-\hypertarget{chap:DWATimportnamespaceusingdirective}{}
+may be represented by an imported 
+module\hypertarget{chap:DWATimportnamespaceusingdirective}{}
 entry, with a \DWATimportDEFN{} attribute referring to the namespace
 entry of the appropriate extension of the namespace (which
 might be the original namespace entry) and no owned entries.
@@ -1115,16 +1141,13 @@ for an example.
 
 \subsection{Imported Unit Entries}
 \label{chap:importedunitentries}
-The 
 \hypertarget{chap:DWATimportimportedunit}{}
-place where a normal or partial compilation unit is imported is
+The place where a normal or partial compilation unit is imported is
 represented by a debugging information entry with the 
 \addtoindexx{imported unit entry}
 tag \DWTAGimportedunitTARG. 
-An imported unit entry contains 
-\addtoindexx{import attribute}
-a
-\DWATimportDEFN{} attribute 
+An imported unit entry contains a
+\DWATimportDEFN{} attribute\addtoindexx{import attribute} 
 whose value is a \livelink{chap:classreference}{reference} to the
 normal or partial compilation unit whose declarations logically
 belong at the place of the imported unit entry.
@@ -1164,19 +1187,17 @@ instance of a subroutine or function \\
 \label{chap:generalsubroutineandentrypointinformation}
 The subroutine or entry point entry has a \DWATname{} 
 attribute whose value is a null-terminated string containing the 
-subroutine or entry point name as it appears in the source program.
+subroutine or entry point name.
+\bbeb
 It may also have a \DWATlinkagename{} attribute as
 described in Section \refersec{chap:linkagenames}.
 
 If the name of the subroutine described by an entry with the
 \addtoindexx{subprogram entry}
-tag \DWTAGsubprogram{}
+tag \DWTAGsubprogram{}\hypertarget{chap:DWATexternalexternalsubroutine}{}
 is visible outside of its containing
-\hypertarget{chap:DWATexternalexternalsubroutine}{}
-compilation unit, that entry has 
-\addtoindexx{external attribute}
-a 
-\DWATexternalDEFN{} attribute,
+compilation unit, that entry has a 
+\DWATexternalDEFN{} attribute,\addtoindexx{external attribute}
 which is a \livelink{chap:classflag}{flag}.
 
 \textit{Additional attributes for functions that are members of a
@@ -1184,12 +1205,9 @@ class or structure are described in
 Section \refersec{chap:memberfunctionentries}.
 }
 
-A 
-\hypertarget{chap:DWATmainsubprogrammainorstartingsubprogram}{}
-subroutine entry 
-may contain a 
-\DWATmainsubprogramDEFN{}
-attribute 
+A\hypertarget{chap:DWATmainsubprogrammainorstartingsubprogram}{}
+subroutine entry may contain a 
+\DWATmainsubprogramDEFN{} attribute 
 \addtoindexx{main subprogram attribute}
 which is 
 a \CLASSflag{} whose presence indicates that the
@@ -1198,16 +1216,17 @@ the program.  If more than one subprogram contains this
 \nolink{flag},
 any one of them may be the starting subroutine of the program.
 
-\textit{\addtoindex{Fortran} has a \addtoindex{PROGRAM statement} 
-which is used to specify
-and provide a user\dash supplied name for the main subroutine of
-a program.
+\textit{%
+\bb 
+See also Section \refersec{chap:unitentries}) regarding the
+related use of this attribute to indicate that a compilation
+unit contains the main subroutine of a program.
+\eb
 }
 
 \subsubsection{Calling Convention Information}
-A subroutine entry may 
 \hypertarget{chap:DWATcallingconventionforsubprograms}{}
-contain a 
+A subroutine entry may contain a 
 \DWATcallingconventionDEFN{}
 \addtoindexx{calling convention attribute!for subprogram}
 attribute, whose value is an 
@@ -1260,47 +1279,40 @@ as a way of finding the entry address for the program.}
 \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-prototype declarations.}
 
 A subroutine entry declared with a function prototype style
 declaration may have 
 \addtoindexx{prototyped attribute}
 a 
 \DWATprototypedNAME{} attribute, which is
-a \CLASSflag.
-
-\textit{The \addtoindex{Fortran} 
-language allows the keywords \texttt{elemental}, \texttt{pure}
-and \texttt{recursive} to be included as part of the declaration of
-a subroutine; these attributes reflect that usage. These
-attributes are not relevant for languages that do not support
-similar keywords or syntax. In particular, the \DWATrecursiveNAME{}
-attribute is neither needed nor appropriate in languages such
-as \addtoindex{C} 
-where functions support recursion by default.
-}
-
-A subprogram entry may have a 
-\hypertarget{chap:DWATelementalelementalpropertyofasubroutine}{}
+a \CLASSflag. 
+\bb
+The attribute indicates whether a subroutine entry point corresponds
+to a function declaration that includes parameter prototype information.
+\eb 
+\bbpareb
+
+A subprogram entry may have 
+a\hypertarget{chap:DWATelementalelementalpropertyofasubroutine}{}
 \DWATelementalDEFN{} attribute,\addtoindexx{elemental attribute} 
 which is a \livelink{chap:classflag}{flag}. 
 The attribute indicates whether the subroutine
 or entry point was declared with the \doublequote{elemental} keyword
 or property.
 
-A 
-\hypertarget{chap:DWATpurepurepropertyofasubroutine}{}
-subprogram entry may have 
+A\hypertarget{chap:DWATpurepurepropertyofasubroutine}{}
+subprogram entry may have a
 \addtoindexx{pure attribute}
-a 
 \DWATpureDEFN{} attribute, which is
 a \livelink{chap:classflag}{flag}. 
 The attribute indicates whether the subroutine was
 declared with the \doublequote{pure} keyword or property.
 
-A 
-\hypertarget{chap:DWATrecursiverecursivepropertyofasubroutine}{}
+A\hypertarget{chap:DWATrecursiverecursivepropertyofasubroutine}{}
 subprogram entry may have a 
+\addtoindexx{recursive attribute}
 \DWATrecursiveDEFN{} attribute, which
 is a \livelink{chap:classflag}{flag}. 
 The attribute indicates whether the subroutine
@@ -1309,14 +1321,35 @@ or property.
 
 A subprogram entry may have a 
 \DWATnoreturnDEFN{}
-\livetargi{chap:DWATnoreturnofsubprogram}{ attribute}{noreturn attribute}, 
+\livetargi{chap:DWATnoreturnofsubprogram}{attribute}{noreturn attribute}, 
 which is a \CLASSflag. The attribute 
 indicates whether the subprogram was declared with the \doublequote{noreturn} keyword or property 
 indicating that the subprogram can be called, but will never return to its caller.
 
+\bb
+\textit{The \addtoindex{Fortran} 
+language allows the keywords \texttt{elemental}, \texttt{pure}
+and \texttt{recursive} to be included as part of the declaration of
+a subroutine; these attributes reflect that usage. These
+attributes are not relevant for languages that do not support
+similar keywords or syntax. In particular, the \DWATrecursiveNAME{}
+attribute is neither needed nor appropriate in languages such
+as \addtoindex{C} 
+where functions support recursion by default.
+}
+\eb
+
 \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,
+\textit{While subprogram attributes in the 
+\bb
+previous 
+\eb
+section provide
+information about the subprogram and 
+\bb
+its 
+\eb
+entry point(s) as a whole,
 the following attributes provide summary information about the calls
 that occur within a subprogram.}
 
@@ -1353,20 +1386,26 @@ that is optimized out is nonetheless also described using a \DWTAGcallsite{} ent
 that has neither a \DWATcallpc{} nor \DWATcallreturnpc{} attribute.
 
 \textit{The \DWATcallallsourcecallsNAME{} attribute is intended for debugging 
-information format consumers that analyse call graphs.}
+information format consumers that 
+\bb
+analyze 
+\eb
+call graphs.}
 
-If the value of the \DWATcallallsourcecalls{} attribute is true then the values of the
-\DWATcallallcalls{} and \DWATcallalltailcalls{} attributes are necessarily also true, and 
-those attributes need not be present. Similarly, if the value of the 
-\DWATcallallcalls{} attribute is true then the value of the \DWATcallalltailcalls{} 
-attribute is also true and the latter attribute need not be present.
+If the 
+\bb
+the \DWATcallallsourcecalls{} attribute is present then the 
+\DWATcallallcalls{} and \DWATcallalltailcalls{} attributes are 
+also implicitly present. Similarly, if the 
+\DWATcallallcalls{} attribute is present then the \DWATcallalltailcalls{} 
+attribute is implicitly present.
+\eb
 
 \needlines{5}
 \subsection{Subroutine and Entry Point Return Types}
 \label{chap:subroutineandentrypointreturntypes}
 
-If 
-\hypertarget{chap:DWATtypetypeofsubroutinereturn}{}
+If\hypertarget{chap:DWATtypetypeofsubroutinereturn}{}
 the subroutine or entry point 
 \addtoindexx{return type of subroutine}
 is a function that returns a
@@ -1399,16 +1438,14 @@ whose
 \addtoindexx{high PC attribute}
 values 
 \addtoindexx{low PC attribute}
-encode the contiguous or non\dash contiguous address
+encode the contiguous or non-contiguous address
 ranges, respectively, of the machine instructions generated
 for the subroutine (see 
 Section \refersec{chap:codeaddressesandranges}).
 
-A 
-\hypertarget{chap:DWATentrypcentryaddressofsubprogram}{}
-subroutine entry may also have 
+A\hypertarget{chap:DWATentrypcentryaddressofsubprogram}{}
+subroutine entry may also have a
 \addtoindexx{entry PC attribute!for subroutine}
-a 
 \DWATentrypc{} attribute
 whose value is the address of the first executable instruction
 of the subroutine (see 
@@ -1418,30 +1455,20 @@ An entry point has a \DWATlowpc{} attribute whose value is the
 relocated address of the first machine instruction generated
 for the entry point.
 
-\textit{While the 
-\DWATentrypc{} attribute 
-\addtoindexx{entry pc attribute!for subroutine}
-might 
-also seem appropriate
-for this purpose, historically the 
-\DWATlowpc{} attribute
-was used before the 
-\DWATentrypc{} was introduced (in
-\addtoindex{DWARF Version 3}). 
-There is insufficient reason to change this.}
-
-
-Subroutines 
-and 
-entry
-\addtoindexx{address class attribute}
-points 
-\hypertarget{chap:DWATaddressclasssubroutineorsubroutinetype}{}
-may also have 
-\DWATsegment{} 
-and
-\DWATaddressclassDEFN{} attributes,
-as appropriate, to specify
+\bbpareb
+%\textit{While the \DWATentrypc{} attribute 
+%\addtoindexx{entry pc attribute!for subroutine}
+%might also seem appropriate for this purpose, historically the 
+%\DWATlowpc{} attribute was used before the 
+%\DWATentrypc{} was introduced (in
+%\addtoindex{DWARF Version 3}). 
+%There is insufficient reason to change this.}
+
+Subroutines and entry points may also have 
+\DWATsegment{}\hypertarget{chap:DWATaddressclasssubroutineorsubroutinetype}{} 
+\addtoindexx{segment attribute} and
+\DWATaddressclassDEFN{}\addtoindexx{address class attribute}
+attributes, as appropriate, to specify
 which segments the code for the subroutine resides in and
 the addressing mode to be used in calling that subroutine.
 
@@ -1482,8 +1509,7 @@ The entry for a subroutine that includes a
 \addtoindexx{common block|see{Fortran common block}}
 has a child entry with the 
 tag \DWTAGcommoninclusionTARG. 
-The
-\hypertarget{chap:commonreferencecommonblockusage}{}
+The\hypertarget{chap:commonreferencecommonblockusage}{}
 common inclusion entry has a 
 \DWATcommonreferenceDEFN{} attribute
 \addtoindexx{common block reference attribute}
@@ -1495,8 +1521,7 @@ for the common \nolink{block} being included
 \subsection{Low-Level Information}
 \label{chap:lowlevelinformation}
 
-A 
-\hypertarget{chap:DWATreturnaddrsubroutinereturnaddresssavelocation}{}
+A\hypertarget{chap:DWATreturnaddrsubroutinereturnaddresssavelocation}{}
 subroutine or entry point entry may have a 
 \addtoindexx{return address attribute}
 \DWATreturnaddrDEFN{}
@@ -1504,11 +1529,9 @@ attribute, whose value is a location description. The location
 specified is the place where the return address for the
 subroutine or entry point is stored.
 
-A 
-\hypertarget{chap:DWATframebasesubroutineframebaseaddress}{}
-subroutine or entry point entry may also have 
+A\hypertarget{chap:DWATframebasesubroutineframebaseaddress}{}
+subroutine or entry point entry may also have a
 \addtoindexx{frame base attribute}
-a
 \DWATframebaseDEFN{} attribute, whose value is a location
 description that describes the \doublequote{frame base} for the
 subroutine or entry point. If the location description is
@@ -1521,10 +1544,8 @@ this interpretation applies to each location description
 contained in the list of \addtoindex{location list} entries.
 
 \textit{The use of one of the \DWOPregn{} 
-operations in this
-context is equivalent to using 
-\DWOPbregn(0) 
-but more
+operations in this context is equivalent to using 
+\DWOPbregn(0) but more
 compact. However, these are not equivalent in general.}
 
 \needlines{5}
@@ -1552,14 +1573,11 @@ outer subroutine from within an inner subroutine. The
 \DWATstaticlink{} and \DWATframebase{} attributes allow
 debuggers to support this same kind of referencing.}
 
-If 
-\hypertarget{chap:DWATstaticlinklocationofuplevelframe}{}
-a 
+If\hypertarget{chap:DWATstaticlinklocationofuplevelframe}{}
+a subroutine or entry point is nested, it may have a
 \addtoindexx{address!uplevel|see {static link attribute}}
 \addtoindexx{uplevel address|see {static link attribute}}
-subroutine or entry point is nested, it may have a
-\DWATstaticlinkDEFN{}
-attribute, whose value is a location
+\DWATstaticlinkDEFN{} attribute, whose value is a location
 description that computes the frame base of the relevant
 instance of the subroutine that immediately encloses the
 subroutine or entry point.
@@ -1575,7 +1593,7 @@ life of the subprogram, and
 \item The computed value should be unique among instances of
 the same subroutine. (For typical \DWATframebase{} use, this
 means that a recursive subroutine\textquoteright s stack frame must have
-non\dash zero size.)
+non-zero size.)
 \end{enumerate}
 
 \textit{If a debugger is attempting to resolve an up\dash level reference
@@ -1635,7 +1653,11 @@ types and values. The exceptions are:
 Section \refersec{chap:templateparameters}.
 
 \needlines{4}
-\item If the compiler has generated a special compilation unit
+\item If the compiler has generated a 
+\bb
+separate
+\eb
+compilation unit
 to hold the template instantiation and that compilation unit
 has a different name from the compilation unit containing
 the template definition, the name attribute for the debugging
@@ -1655,16 +1677,13 @@ artificially by the compiler for this instantiation.
 \label{chap:inlinedsubroutines}
 A declaration or a definition of an inlinable subroutine
 is represented by a debugging information entry with the
-tag 
-\DWTAGsubprogram.
-The entry for a 
+tag \DWTAGsubprogram.
+The entry for a subroutine 
 \addtoindexx{subprogram entry!use in inlined subprogram}
-subroutine that is
-\hypertarget{chap:DWATinlineinlinedsubroutine}{}
+that is\hypertarget{chap:DWATinlineinlinedsubroutine}{}
 explicitly declared to be available for inline expansion or
-that was expanded inline implicitly by the compiler has 
+that was expanded inline implicitly by the compiler has a
 \addtoindexx{inline attribute}
-a
 \DWATinlineDEFN{} attribute whose value is an 
 \livelink{chap:classconstant}{integer constant}. The
 set of values for the \DWATinline{} attribute is given in
@@ -1690,8 +1709,13 @@ Name&Meaning\\ \hline
 \end{table}
 
 \textit{In \addtoindex{C++}, a function or a constructor declared with
-\addttindex{constexpr} is implicitly declared inline. The abstract inline
-instance (see below) is represented by a debugging information
+\addttindex{constexpr} is implicitly declared inline. The abstract
+\bbeb
+instance (see 
+\bb
+Section \refersec{chap:abstractinstances}) 
+\eb
+is represented by a debugging information
 entry with the tag \DWTAGsubprogram. Such an entry has a
 \DWATinline{} attribute whose value is \DWINLinlined.}
 
@@ -1703,16 +1727,23 @@ Any subroutine entry that contains a
 whose value is other than 
 \DWINLnotinlined{}
 is known as an
-\doublequote{abstract instance root.}\addtoindexx{abstract instance!root}
+\bb
+\definition{abstract instance root}.
+\eb
+\addtoindexx{abstract instance!root}
 \hypertarget{chap:DWATinlineabstracttinstance}{}
 Any debugging information entry that is owned (either
 directly or indirectly) by an abstract instance root
 is known as an
-\doublequote{abstract instance entry.}\addtoindexx{abstract instance!entry}
+\bb
+\definition{abstract instance entry.}\addtoindexx{abstract instance!entry}
+\eb
 Any set of abstract instance entries that are all
 children (either directly or indirectly) of some abstract
 instance root, together with the root itself, is known as an
-\doublequote{abstract instance tree.}\addtoindexx{abstract instance!tree}
+\bb
+\definition{abstract instance tree.}\addtoindexx{abstract instance!tree}
+\eb
 However, in the case where an abstract instance tree is 
 nested within another abstract instance tree, the entries in the 
 \addtoindex{nested abstract instance}
@@ -1731,13 +1762,20 @@ to refer to the declaration in context.
 declaration or a class declaration.}
 
 \textit{Abstract instance trees are defined so that no entry is part
-of more than one abstract instance tree. This simplifies the
-following descriptions.}
+of more than one abstract instance tree. 
+\bbeb
+}
+
+Attributes 
+\bb
+and children in an abstract instance are shared
+by all concrete instances (see Section \refersec{chap:concreteinstances}).
+\eb
 
 A debugging information entry that is a member of an abstract
 instance tree should not contain any attributes which describe
 aspects of the subroutine which vary between distinct inlined
-expansions or distinct out\dash of\dash line expansions. For example,
+expansions or distinct out-of-line expansions. For example,
 \addtoindexx{entry pc attribute!and abstract instance}
 the \DWATlowpc,
 \DWAThighpc, 
@@ -1779,14 +1817,16 @@ abstract instance trees are exactly the same as for other
 similar types of entries that are not abstract. Specifically,
 the rule that requires that an entry representing a declaration
 be a direct child of the entry representing the scope of the
-declaration applies equally to both abstract and non\dash abstract
+declaration applies equally to both abstract and non-abstract
 entries. Also, the ordering rules for formal parameter entries,
 member entries, and so on, all apply regardless of whether
 or not a given entry is abstract.
 
 \needlines{5}
-\subsubsection{Concrete Inlined Instances}
-\label{chap:concreteinlinedinstances}
+\bb
+\subsubsection{Concrete Instances}
+\eb
+\label{chap:concreteinstances}
 
 Each inline expansion of a subroutine is represented
 by a debugging information entry with the 
@@ -1807,12 +1847,11 @@ or
 \addtoindexx{ranges attribute}
 a 
 \DWATranges{}
-attribute whose values encode the contiguous or non\dash contiguous
+attribute whose values encode the contiguous or non-contiguous
 address ranges, respectively, of the machine instructions
 generated for the inlined subroutine (see 
 Section \referfol{chap:codeaddressesandranges}). 
-An
-\hypertarget{chap:DWATentrypcentryaddressofinlinedsubprogram}{}
+An\hypertarget{chap:DWATentrypcentryaddressofinlinedsubprogram}{}
 inlined subroutine entry may 
 \addtoindexx{inlined subprogram entry!in concrete instance}
 also 
@@ -1826,12 +1865,9 @@ the inline expansion (see
 Section \refersec{chap:entryaddress}).
 
 % Positions of the 3 targets here is a bit arbitrary.
-An inlined 
-\hypertarget{chap:DWATcalllinelinenumberofinlinedsubroutinecall}{}
-subroutine 
-\hypertarget{chap:DWATcallcolumncolumnpositionofinlinedsubroutinecall}{}
-entry 
-\hypertarget{chap:DWATcallfilefilecontaininginlinedsubroutinecall}{}
+An inlined\hypertarget{chap:DWATcalllinelinenumberofinlinedsubroutinecall}{}
+subroutine\hypertarget{chap:DWATcallcolumncolumnpositionofinlinedsubroutinecall}{}
+entry\hypertarget{chap:DWATcallfilefilecontaininginlinedsubroutinecall}{}
 may also have \DWATcallfileDEFN,
 \DWATcalllineDEFN{} and \DWATcallcolumnDEFN{} attributes,
 \addtoindexx{inlined call location attributes} 
@@ -1851,9 +1887,8 @@ describe the coordinates of the subroutine declaration that
 was inlined, rather they describe the coordinates of the call.
 }
 
-An inlined subroutine entry 
-\hypertarget{chap:DWATconstexprcompiletimeconstantfunction}{}
-may have a 
+An inlined subroutine entry may have
+a\hypertarget{chap:DWATconstexprcompiletimeconstantfunction}{}
 \DWATconstexprDEFN{} attribute,\addtoindexx{constant expression attribute} 
 which is a \livelink{chap:classflag}{flag} 
 whose presence indicates that the
@@ -1906,11 +1941,10 @@ Concrete inlined instance entries may omit attributes that
 are not specific to the concrete instance (but present in
 the abstract instance) and need include only attributes that
 are specific to the concrete instance (but omitted in the
-abstract instance). In place of these omitted attributes, each
-\hypertarget{chap:DWATabstractorigininlineinstance}{}
-concrete inlined instance entry 
+abstract instance). In place of these omitted attributes, 
+each\hypertarget{chap:DWATabstractorigininlineinstance}{}
+concrete inlined instance entry has a
 \addtoindexx{abstract origin attribute}
-has a 
 \DWATabstractoriginDEFN{}
 attribute that may be used to obtain the missing information
 (indirectly) from the associated abstract instance entry. The
@@ -2045,7 +2079,7 @@ Some languages and compilers may permit the logical nesting of
 a subroutine within another subroutine, and may permit either
 the outer or the nested subroutine, or both, to be inlined.
 
-For a non\dash inlined subroutine nested within an inlined
+For a non-inlined subroutine nested within an inlined
 subroutine, the nested subroutine is described normally in
 both the abstract and concrete inlined instance trees for
 the outer subroutine. All rules pertaining to the abstract
@@ -2083,7 +2117,7 @@ out-of-line
 expansion of the nested subroutine is described within a
 concrete instance tree for the outer subroutine according
 to the rules in 
-Sections \refersec{chap:concreteinlinedinstances} or 
+Sections \refersec{chap:concreteinstances} or 
 \referfol{chap:outoflineinstancesofinlinedsubroutines}
 , respectively,
 and without regard to the fact that it is within an outer
@@ -2096,8 +2130,8 @@ for discussion and examples.
 \subsection{Trampolines}
 \label{chap:trampolines}
 
-\textit{A trampoline is a compiler\dash generated subroutine that serves as
-\hypertarget{chap:DWATtrampolinetargetsubroutine}{}
+\textit{A trampoline is a compiler\dash generated subroutine that serves 
+as\hypertarget{chap:DWATtrampolinetargetsubroutine}{}
 an intermediary in making a call to another subroutine. It may
 adjust parameters and/or the result (if any) as appropriate
 to the combined calling and called execution contexts.}
@@ -2116,8 +2150,8 @@ control. (A trampoline entry may but need not also have a
 
 \needlines{5}
 The value of the trampoline attribute may be represented
-using any of the following forms, which are listed in order
-of preference:
+using any of the following forms:
+\bbeb
 
 \begin{itemize}
 \item If the value is of class \CLASSreference{}, then the value
@@ -2139,7 +2173,7 @@ that the target subroutine is not known.
 
 
 The target subprogram may itself be a trampoline. (A sequence
-of trampolines necessarily ends with a non\dash trampoline
+of trampolines necessarily ends with a non-trampoline
 subprogram.)
 
 \textit{In \addtoindex{C++}, trampolines may be used to implement 
@@ -2161,14 +2195,15 @@ a trampoline will result in stepping into or setting the
 breakpoint in the target subroutine instead. This helps to
 hide the compiler generated subprogram from the user. }
 
-\textit{If the target subroutine is not known, a debugger may choose
-to repeatedly step until control arrives in a new subroutine
-which can be assumed to be the target subroutine. }
+\bbpareb
 
-\subsection{Call Site Entries}
+\bb
+\section{Call Site Entries}
+\eb
 \label{chap:callsiteentries}
 \textit{
-A call site entry provides a way to represent the static or dynamic 
+A call site entry provides a way to represent the 
+\bbeb 
 call graph of a program in the debugging information. It also provides
 information about how parameters are passed so that they may be more
 easily accessed by a debugger. Together with the \DWOPentryvalue{} opcode,
@@ -2176,17 +2211,23 @@ call site entries can be also useful for computing values of variables
 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 it's call site information and then
+The consumer can then use unwind information to find the caller and 
+\bb
+its 
+\eb
+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
+\DWTAGcallsiteTARG{}\addtoindexx{call site entry}. 
+The entry for a call site is owned by the innermost
 debugging information entry representing the scope within which the
 call is present in the source program.
 
 \needlines{4}
-\textit{A scope entry (for example, for a lexical block) that would not 
+\textit{A scope entry (for example, 
+\bbeb 
+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.}
@@ -2203,8 +2244,11 @@ 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 jump into the middle of the
-current subroutine.
+to the current subroutine which is compiled as a jump 
+\bb
+to
+\eb
+the current subroutine.
 \needlines{4}
 \item
 An \textit{inline (or inlined) call} is a call to an inlined subprogram,
@@ -2230,8 +2274,11 @@ instructions are given a location in the caller.
 while \DWTAGinlinedsubroutine{} entries describe inlined calls 
 (see Section \refersec{chap:inlinedsubroutines}).
 
-The call site entry has a 
-\DWATcallreturnpcDEFN{}
+The call site entry 
+\bb
+may have
+\eb
+a \DWATcallreturnpcDEFN{}\addtoindexx{call site return pc attribute}
 \livetargi{chap:DWATcallreturnpcofcallsite}{attribute}{call return pc attribute} 
 which is the return address after the call.  
 The value of this attribute corresponds to the return address computed by 
@@ -2243,27 +2290,27 @@ call instruction, but on architectures with delay slots it might
 be an address after the delay slot of the call.}
 
 The call site entry may have a 
-\DWATcallpcDEFN{}
+\DWATcallpcDEFN{}\addtoindexx{call pc attribute}
 \livetargi{chap:DWATcallpcofcallsite}{attribute}{call pc attribute} which is the
 address of the call instruction.
 
 If the call site entry corresponds to a tail call, it has the 
-\DWATcalltailcallDEFN{}
+\DWATcalltailcallDEFN{}\addtoindexx{call tail call attribute}
 \livetargi{chap:DWATcalltailcallofcallsite}{attribute}{call tail call attribute},
 which is a \CLASSflag.
 
 The call site entry may have a 
-\DWATcalloriginDEFN{}
+\DWATcalloriginDEFN{}\addtoindexx{call origin attribute}
 \livetargi{chap:DWATcalloriginofcallsite}{attribute}{call origin attribute}
-which is a \CLASSreference.  For direct calls or jumps where the called subprogram is
-known it is a reference to the called subprogram's debugging
+which is a \CLASSreference.  For direct calls or jumps where the called 
+subprogram is known it is a reference to the called subprogram's debugging
 information entry.  For indirect calls it may be a reference to a
 \DWTAGvariable{}, \DWTAGformalparameter{} or \DWTAGmember{} entry representing
 the subroutine pointer that is called.
 
 \needlines{4}
 The call site may have a 
-\DWATcalltargetDEFN{}
+\DWATcalltargetDEFN{}\addtoindexx{call target attribute}
 \livetargi{chap:DWATcalltargetofcallsite}{attribute}{call target attribute} which is
 a DWARF expression.  For indirect calls or jumps where it is unknown at
 compile time which subprogram will be called the expression computes the
@@ -2272,21 +2319,31 @@ not use register or memory locations that might be clobbered by the call.
 
 \needlines{4}
 The call site entry may have a 
-\DWATcalltargetclobberedDEFN{}
+\DWATcalltargetclobberedDEFN{}\addtoindexx{call target clobbered attribute}
 \livetargi{chap:DWATcalltargetclobberedofcallsite}{attribute}{call target clobbered attribute}
 which is a DWARF expression.  For indirect calls or jumps where the
 address is not computable without use of registers or memory locations that
 might be clobbered by the call the \DWATcalltargetclobberedNAME{}
 attribute is used instead of the \DWATcalltarget{} attribute.
 
-The call site entry may have a \DWATtypeDEFN{}
+\textit{The
+\bb
+expression of a call target clobbered attribute may only be valid 
+at the time the call or call-like transfer of control is executed.
+\eb
+}
+
+The call site entry may have a 
+\DWATtypeDEFN{}\addtoindexx{call type attribute}
 \livetargi{chap:DWATtypeofcallsite}{attribute}{type attribute!of call site entry}
 referencing a debugging information entry for the type of the called function.  
 
 \textit{When \DWATcallorigin{} is present, \DWATtypeNAME{} is usually omitted.}
 
 The call site entry may have 
-\DWATcallfileNAME{}, \DWATcalllineNAME{} and \DWATcallcolumnNAME{} 
+\DWATcallfileDEFN{}\addtoindexx{call file attribute}, 
+\DWATcalllineDEFN{}\addtoindexx{call line attribute} and 
+\DWATcallcolumnDEFN{}\addtoindexx{call column attribute} 
 \livetargi{chap:DWATcallfileofcallsite}{attributes,}{call file attribute!of call site entry}
 \livetargi{chap:DWATcalllineofcallsite}{}{call line attribute!of call site entry}
 \livetargi{chap:DWATcallcolumnofcallsite}{}{call column attribute!of call site entry}
@@ -2303,8 +2360,9 @@ coordinates of the subroutine declaration that was called, rather they describe
 the coordinates of the call.}
 
 \needlines{5}
-The call site entry may own \DWTAGcallsiteparameterTARG{} debugging information
-entries\index{call site parameter entry} representing the parameters passed to the call.
+The call site entry may own 
+\DWTAGcallsiteparameterTARG{}\index{call site parameter entry} 
+debugging information entries representing the parameters passed to the call.
 Each such entry has a \DWATlocation{} attribute which is a location expression.
 This location expression describes where the parameter is passed
 (usually either some register, or a memory location expressible as the
@@ -2312,48 +2370,60 @@ contents of the stack register plus some offset).
 
 \needlines{4}
 Each \DWTAGcallsiteparameter{} entry may have a 
-\DWATcallvalueDEFN{}
+\DWATcallvalueDEFN{}\addtoindexx{call value attribute}
 \livetargi{chap:DWATcallvalueofcallparameter}{attribute}{call value attribute}
-which is a DWARF expression.  This expression computes the value
-passed for that parameter.  The expression should not use registers or memory
+which is a DWARF expression 
+\bb 
+which when evaluated yields the value of the parameter at the time of the call.
+\eb
+
+\textit{The expression should not use registers or memory
 locations that might be clobbered by the call, as it might be evaluated after
 unwinding from the called function back to the caller.  If it is not
 possible to avoid registers or memory locations that might be clobbered by
 the call in the expression, then the \DWATcallvalueNAME{} attribute should
-not be provided.
+not be provided.}
 
 \textit{The reason for the restriction is that the value of the parameter may be
-needed in the middle of the callee, where the call clobbered registers or
-memory might be already clobbered, and if the consumer was not assured by
-the producer it can safely use those values, the consumer could not safely
+needed in the midst of the callee, where the call clobbered registers or
+memory might be already clobbered, and if the consumer is not assured by
+the producer it can safely use those values, the consumer can not safely
 use the values at all.}
 
 For parameters passed by reference, where the code passes a pointer to
-a location which contains the parameter, or for reference type parameters
+a location which contains the parameter, or for reference type parameters,
 the \DWTAGcallsiteparameter{} entry may also have 
-\DWATcalldatalocationNAME{}
+\bb
+a
+\eb
+\DWATcalldatalocationNAME{}\addtoindexx{call data location attribute}
 \livetargi{chap:DWATcalldatalocationofcallparameter}{attribute}{call data location attribute}
 whose value is a location expression and a
-\DWATcalldatavalueNAME{}
+\DWATcalldatavalueNAME{}\addtoindexx{call data value attribute}
 \livetargi{chap:DWATcalldatavalueofcallparameter}{attribute}{call data value attribute}
 whose value is a DWARF expression.  The \DWATcalldatalocationDEFN{} attribute
 \addtoindexx{call data location attribute} 
 describes where the referenced value lives during the call.  If it is just 
 \DWOPpushobjectaddress{}, it may be left out.  The 
-\DWATcalldatavalueNAME{} attribute\addtoindexx{call data value attribute}
-describes the value in that location. 
+\DWATcalldatavalueNAME{} attribute describes the value in that location. 
 The expression should not use registers or memory
 locations that might be clobbered by the call, as it might be evaluated after
 unwinding from the called function back to the caller.
 
 \needlines{4}
 Each call site parameter entry may also have a 
-\DWATcallparameterDEFN{}
+\DWATcallparameterDEFN{}\addtoindexx{call parameter attribute}
 \livetargi{chap:DWATcallparameterofcallparameter}{attribute}{call parameter attribute}
 which contains a reference to a \DWTAGformalparameter{} entry,
-\DWATtype{} attribute referencing the type of the parameter or \DWATname{}
-attribute describing the parameter's name.
+\DWATtype{} attribute referencing the type of the parameter or 
+\DWATname{} attribute describing the parameter's name.
 
+\textit{Examples
+\bb
+using call site entries and related attributes are found in 
+Appendix \refersec{app:callsiteexamples}.
+\eb
+}
 
 \needlines{8}
 \section{Lexical Block Entries}
@@ -2390,64 +2460,70 @@ ranges, respectively, of the machine instructions generated
 for the lexical \nolink{block} 
 (see Section \refersec{chap:codeaddressesandranges}).
 
-A 
-\hypertarget{chap:DWATentrypcoflexicalblock}{}
-lexical block entry may also have 
+A\hypertarget{chap:DWATentrypcoflexicalblock}{}
+lexical block entry may also have a
 \addtoindexx{entry PC attribute!for lexical block}
-a 
 \DWATentrypc{} attribute
 whose value is the address of the first executable instruction
 of the lexical block (see 
 Section \refersec{chap:entryaddress}).
 
-If a name has been given to the 
-lexical \nolink{block} 
-in the source
-program, then the corresponding 
+If a name has been given to the lexical \nolink{block} 
+in the source program, then the corresponding 
 lexical \nolink{block} entry has a
 \DWATname{} attribute whose 
 \addtoindexx{name attribute}
-value is a null\dash terminated string
-containing the name of the lexical \nolink{block} 
-as it appears in
-the source program.
+value is a null-terminated string
+containing the name of the lexical \nolink{block}.
+\bbeb 
 
 \textit{This is not the same as a \addtoindex{C} or 
-\addtoindex{C++} label (see below).}
+\addtoindex{C++} label (see 
+\bb
+Section \refersec{chap:labelentries}).
+\eb
+}
 
-The lexical \nolink{block} entry owns 
-debugging information entries that
-describe the declarations within that lexical \nolink{block}. 
-There is
+The lexical \nolink{block} entry owns debugging 
+information entries that describe the declarations 
+within that lexical \nolink{block}. There is
 one such debugging information entry for each local declaration
 of an identifier or inner lexical \nolink{block}.
 
 \needlines{10}
 \section{Label Entries}
 \label{chap:labelentries}
-\textit{A label is a way of identifying a source statement. A labeled
-statement is usually the target of one or more \doublequote{go to}
-statements.
+\textit{A label is a way of identifying a source 
+\bb
+location.
+\eb
+A labeled statement is usually the target of one or more 
+\doublequote{go to} statements.
 }
 
 \needlines{4}
 A label is represented by a debugging information entry with
 \addtoindexx{label entry}
-the 
-tag \DWTAGlabelTARG. 
+the tag \DWTAGlabelTARG. 
 The entry for a label should be owned by
 the debugging information entry representing the scope within
 which the name of the label could be legally referenced within
 the source program.
 
 The label entry has a \DWATlowpc{} attribute whose value
-is the relocated address of the first machine instruction
-generated for the statement identified by the label in
+is the 
+\bbeb
+address of the first 
+\bb
+executable instruction for the location
+\eb
+identified by the label in
 the source program.  The label entry also has a 
 \DWATname{} attribute 
 \addtoindexx{name attribute}
 whose value is a null-terminated string containing
-the name of the label as it appears in the source program.
+the name of the label.
+\bbeb
 
 
 \section{With Statement Entries}
@@ -2455,7 +2531,7 @@ the name of the label as it appears in the source program.
 
 \textit{Both \addtoindex{Pascal} and 
 \addtoindexx{Modula-2}
-Modula\dash 2 support the concept of a \doublequote{with}
+Modula-2 support the concept of a \doublequote{with}
 statement. The with statement specifies a sequence of
 executable statements within which the fields of a record
 variable may be referenced, unqualified by the name of the
@@ -2473,7 +2549,7 @@ or
 \addtoindexx{low PC attribute}
 a \DWATranges{} attribute
 \addtoindexx{ranges attribute}
-whose values encode the contiguous or non\dash contiguous address
+whose values encode the contiguous or non-contiguous address
 ranges, respectively, of the machine instructions generated
 for the with statement 
 (see Section \refersec{chap:codeaddressesandranges}).
@@ -2535,12 +2611,11 @@ or non-contiguous address ranges, respectively, of the
 machine instructions generated for the \nolink{block}
 (see Section \refersec{chap:codeaddressesandranges}).
 
-\hypertarget{chap:DWATentrypcoftryblock}{}
-\hypertarget{chap:DWATentrypcofcatchblock}{}
-A try or catch block entry may also have 
+A\hypertarget{chap:DWATentrypcoftryblock}{}
+try or catch\hypertarget{chap:DWATentrypcofcatchblock}{}
+block entry may also have a
 \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
 of the try or catch block 
index fbdc9ed..896e724 100644 (file)
@@ -905,7 +905,7 @@ consumer to look up a compilation unit (by its \CUsignature) or
 a type unit (by its \TUsignature), and locate each contribution 
 that belongs to that unit.
 
-As an example, consider a package file, \texttt{demo.dwp}, formed by
+For example, consider a package file, \texttt{demo.dwp}, formed by
 combining \texttt{demo1.dwo} and \texttt{demo2.dwo} from the previous example
 (see Appendix \refersec{app:splitdwarfobjectfileexample}). The
 resulting package file would contain the sections shown in Figure
index 52cb8af..1e0b301 100644 (file)
@@ -4,12 +4,13 @@ This section presents the debugging information entries
 that describe program types: base types, modified types and
 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
+If the scope of the declaration of a named type begins 
+after\hypertarget{chap:DWATstartscopetypedeclaration}{}
+\bbeb 
+the scope most closely enclosing the
 declaration, the declaration may have a 
-\DWATstartscopeDEFN{}
-attribute as described for objects in 
+\addtoindexx{start scope attribute}
+\DWATstartscopeDEFN{} attribute as described for objects in 
 Section \refersec{chap:dataobjectentries}.
 
 \section{Base Type Entries}
@@ -47,13 +48,13 @@ 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
-\hypertarget{chap:DWATbitsizebasetypebitsize}{}
-or a \DWATbitsize{} attribute 
+A base type entry has either a
+\addtoindexx{byte size attribute}
+\DWATbytesize{}\hypertarget{chap:DWATbytesizedataobjectordatatypesize}{}
+attribute or a
 \addtoindexx{bit size attribute}
-whose \livelink{chap:classconstant}{integer constant} value
+\DWATbitsize{}\hypertarget{chap:DWATbitsizebasetypebitsize}{} 
+attribute whose \livelink{chap:classconstant}{integer constant} value
 (see Section \refersec{chap:byteandbitsizes}) 
 is the amount of storage needed to hold
 a value of the type.
@@ -67,8 +68,8 @@ whose value is \DWATEsigned{}
 and a byte size attribute whose value is 4.}
 
 If the value of an object of the given type does not fully
-occupy the storage described by a byte size attribute,
-\hypertarget{chap:DWATdatabitoffsetbasetypebitlocation}{}
+occupy the storage described by a byte size 
+attribute,\hypertarget{chap:DWATdatabitoffsetbasetypebitlocation}{}
 the base type entry may also have a 
 \DWATbitsizeDEFN{} and a \DWATdatabitoffsetDEFN{} attribute,
 \addtoindexx{bit size attribute}
@@ -154,32 +155,44 @@ DWARF specification.}
 \end{table}
 
 \subsubsection{Simple Encodings}
-\label{simpleencodings}
+\label{chap:simpleencodings}
 Types with simple encodings are widely supported in many
-programming languages and do not require further discussion.
+programming languages and 
+\bb
+are not discussed further.
+\eb
 
 \needlines{6}
 \subsubsection{Character Encodings}
-\label{characterencodings}
-The \DWATEUTF{} encoding is intended for \addtoindex{Unicode}
-string encodings (see the Universal Character Set standard,
+\label{chap:characterencodings}
+\DWATEUTF{} 
+\bb
+specifies the \addtoindex{Unicode} string encoding
+\eb
+(see the Universal Character Set standard,
 ISO/IEC 10646\dash 1:1993).
 \addtoindexx{ISO 10646 character set standard}
-For example, the 
-\addtoindex{C++} type char16\_t is
+
+\textit{For
+\bb
+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.
+\eb
+}
 
 \needlines{4}
-The \DWATEASCII{} and \DWATEUCS{} encodings are intended for
-the {Fortran 2003} string kinds 
+\bb
+\DWATEASCII{} and \DWATEUCS{} specify encodings for
+\eb
+the \addtoindex{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).
 \addtoindexx{ISO 10646 character set standard}
 
 \subsubsection{Scaled Encodings}
-\label{scaledencodings}
+\label{chap:scaledencodings}
 The \DWATEsignedfixed{} and \DWATEunsignedfixed{} entries
 describe signed and unsigned fixed\dash point binary data types,
 respectively.
@@ -198,8 +211,8 @@ 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
+For\hypertarget{chap:DWATbinaryscalebinaryscalefactorforfixedpointtype}{}
+a data type with a binary scale factor, the fixed
 binary type entry has a \DWATbinaryscaleNAME{} attribute. 
 The \DWATbinaryscaleDEFN{} attribute\addtoindexx{binary scale attribute} 
 is an \livelink{chap:classconstant}{integer constant} value
@@ -213,8 +226,7 @@ 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}{}
+For\hypertarget{chap:DWATsmallscalefactorforfixedpointtype}{}
 a data type with a non-decimal and non-binary scale factor,
 the fixed binary type entry has a \DWATsmallDEFN{} attribute which
 \addtoindexx{small attribute} references a 
@@ -233,11 +245,17 @@ entry for the type.
 Types with binary floating-point encodings 
 (\DWATEfloat{}, \DWATEcomplexfloat{} and \DWATEimaginaryfloat{})
 are supported in many
-programming languages and do not require further discussion.
+programming languages and 
+\bb
+are not discussed further.
+\eb
+
 
-The \DWATEdecimalfloat{} encoding is intended for
+\bb
+\DWATEdecimalfloat{} specifies 
 floating-point representations that have a power-of-ten
-exponent, such as that specified in IEEE 754R.
+exponent, such as specified in IEEE 754R.
+\eb
 
 \subsubsection{Decimal String Encodings}
 \label{chap:decimalstringencodings}
@@ -258,8 +276,8 @@ base types are used in combination with
 attributes.
 
 \needlines{5}
-\hypertarget{chap:DWATdecimalsigndecimalsignrepresentation}{}
-\DWATdecimalsignDEFN{} attribute 
+A\hypertarget{chap:DWATdecimalsigndecimalsignrepresentation}{}
+\DWATdecimalsignDEFN{} attribute 
 \addtoindexx{decimal sign attribute}
 is an \livelink{chap:classconstant}{integer constant} that
 conveys the representation of the sign of the decimal type
@@ -296,9 +314,8 @@ indicating positive or negative. \\
 \end{table}
 
 \needlines{4}
-\hypertarget{chap:DWATdecimalscaledecimalscalefactor}{}
-The \DWATdecimalscaleDEFN{}
-attribute 
+The\hypertarget{chap:DWATdecimalscaledecimalscalefactor}{}
+\DWATdecimalscaleDEFN{} attribute 
 \addtoindexx{decimal scale attribute}
 is an integer constant value
 that represents the exponent of the base ten scale factor to
@@ -311,16 +328,15 @@ 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 \DWATdigitcountDEFN{} attribute 
+The\hypertarget{chap:DWATdigitcountdigitcountforpackeddecimalornumericstringtype}{} 
+\DWATdigitcountDEFN{} attribute 
 \addtoindexx{digit count attribute}
-\hypertarget{chap:DWATdigitcountdigitcountforpackeddecimalornumericstringtype}{}
 is an \livelink{chap:classconstant}{integer constant}
 value that represents the number of digits in an instance of
 the type.
 
-The \DWATEedited{} base 
-\hypertarget{chap:DWATpicturestringpicturestringfornumericstringtype}{}
-type is used to represent an edited
+The\hypertarget{chap:DWATpicturestringpicturestringfornumericstringtype}{}
+\DWATEedited{} base type is used to represent an edited
 numeric or alphanumeric data type. It is used in combination
 with a \DWATpicturestringDEFN{} attribute whose value is a 
 null\dash terminated string containing the target\dash dependent picture
@@ -362,7 +378,8 @@ has a \DWATname{} attribute
 \addtoindexx{name attribute}
 whose value is
 a null\dash terminated
-string containing the name as it appears in the source program.
+string containing the name.
+\bbeb
 
 \textit{The interpretation of this debugging information entry is
 intentionally left flexible to allow it to be interpreted
@@ -413,8 +430,8 @@ program, then the corresponding modified type entry has
 a \DWATname{} attribute 
 \addtoindexx{name attribute}
 whose value is a null\dash terminated
-string containing the modified type name as it appears in
-the source program.
+string containing the modified type name
+\bbeb
 
 Each of the type modifier entries has 
 \addtoindexx{type attribute}
@@ -432,14 +449,15 @@ pointer or \addtoindex{reference type}
 \DWTAGreferencetype{} or
 \DWTAGrvaluereferencetype) 
 % Another instance of no-good-place-to-put-index entry.
-may
-\addtoindexx{address class attribute} 
-have 
-\hypertarget{chap:DWATadressclasspointerorreferencetypes}{}
-a 
-\DWATaddressclassDEFN{}
+may have
+a\hypertarget{chap:DWATadressclasspointerorreferencetypes}{}
+\DWATaddressclassDEFN{}\addtoindexx{address class attribute} 
 attribute to describe how objects having the given pointer
-or reference type ought to be dereferenced.
+or reference type 
+\bb
+are
+\eb
+dereferenced.
 
 A modified type entry describing a \addtoindex{UPC} shared qualified type
 (using \DWTAGsharedtype) may have a
@@ -558,7 +576,8 @@ the tag \DWTAGtypedefTARG.
 The typedef entry has a \DWATname{} attribute 
 \addtoindexx{name attribute}
 whose value is a null\dash terminated string containing
-the name of the typedef as it appears in the source program.
+the name of the typedef.
+\bbeb
 
 The typedef entry may also contain 
 \addtoindexx{type attribute}
@@ -598,11 +617,10 @@ the array type in the source program, then the corresponding
 array type entry has a \DWATname{} attribute 
 \addtoindexx{name attribute}
 whose value is a
-null\dash terminated string containing the array type name as it
-appears in the source program.
+null-terminated string containing the array type name.
+\bbeb
 
-The 
-\hypertarget{chap:DWATorderingarrayrowcolumnordering}{}
+The\hypertarget{chap:DWATorderingarrayrowcolumnordering}{}
 array type entry describing a multidimensional array may
 \addtoindexx{array!element ordering}
 have a \DWATorderingDEFN{} attribute whose 
@@ -624,8 +642,7 @@ of the enclosing compilation unit entry) is assumed.
 \DWORDrowmajorTARG{} \\
 \end{simplenametable}
 
-The ordering attribute may optionally appear on one-dimensional
-arrays; it will be ignored.
+\bbpareb
 
 An array type entry has 
 \addtoindexx{type attribute}
@@ -637,20 +654,16 @@ the type of each element of the array.
 If the amount of storage allocated to hold each element of an
 object of the given array type is different from the amount
 \addtoindexx{stride attribute|see{bit stride attribute or byte stride attribute}}
-of storage that is normally allocated to hold an individual
-\hypertarget{chap:DWATbitstridearrayelementstrideofarraytype}{}
-object of the 
-\hypertarget{chap:DWATbytestridearrayelementstrideofarraytype}{}
-indicated element type, then the array type
-\addtoindexx{bit stride attribute}
-entry has either a 
-\DWATbytestrideDEFN{} 
-or 
+of storage that is normally allocated to hold an individual object
+of\hypertarget{chap:DWATbitstridearrayelementstrideofarraytype}{}
+the\hypertarget{chap:DWATbytestridearrayelementstrideofarraytype}{}
+indicated element type, then the array type entry has either a
 \addtoindexx{byte stride attribute}
-a \DWATbitstrideDEFN{}
-attribute, 
+\DWATbytestrideDEFN{} 
+or a
 \addtoindexx{bit stride attribute}
-whose value 
+\DWATbitstrideDEFN{}
+attribute, whose value 
 (see Section \refersec{chap:staticanddynamicvaluesofattributes}) 
 is the size of each
 element of the array.
@@ -723,8 +736,8 @@ with the tag \DWTAGcoarraytypeTARG.
 If a name has been given to the 
 coarray type in the source, then the corresponding coarray type 
 entry has a \DWATname{} attribute whose value is a null-terminated 
-string containing the array type name as it appears in the source 
-program.
+string containing the array type name.
+\bbeb
 
 A coarray entry has one or more \DWTAGsubrangetype{} child entries,
 one for each codimension. It also has a \DWATtype{} attribute 
@@ -800,7 +813,8 @@ structure type, union type, or class type entry has a
 \DWATname{} attribute 
 \addtoindexx{name attribute}
 whose value is a null\dash terminated string
-containing the type name as it appears in the source program.
+containing the type name.
+\bbeb
 
 The members of a structure, union, or class are represented
 by debugging information entries that are owned by the
@@ -818,10 +832,9 @@ defined within the containing structure, union, or class.
 \textit{This may be used to describe anonymous structures, unions 
 and classes in \addtoindex{C} or \addtoindex{C++}}.
 
-A structure type, union type or class type entry may have
-either a \DWATbytesize{} or a
-\DWATbitsize{} attribute 
-\hypertarget{chap:DWATbitsizedatamemberbitsize}{}
+A\hypertarget{chap:DWATbitsizedatamemberbitsize}{} 
+structure type, union type or class type entry may have
+either a \DWATbytesize{} or a \DWATbitsize{} attribute 
 (see Section \refersec{chap:byteandbitsizes}), 
 whose value is the amount of storage needed
 to hold an instance of the structure, union or class type,
@@ -829,15 +842,14 @@ including any padding.
   
 An incomplete structure, union or class type 
 \addtoindexx{incomplete structure/union/class}
-is 
 \addtoindexx{incomplete type}
-represented by a structure, union or class
+is represented by a structure, union or class
 entry that does not have a byte size attribute and that has
 \addtoindexx{declaration attribute}
 a \DWATdeclaration{} attribute.
 
-If the complete declaration of a type has been placed in
-\hypertarget{chap:DWATsignaturetypesignature}{}
+If the complete declaration of a type has been placed 
+in\hypertarget{chap:DWATsignaturetypesignature}{}
 a separate \addtoindex{type unit}
 (see Section \refersec{chap:typeunitentries}), 
 an incomplete declaration 
@@ -887,7 +899,7 @@ its definition. That latter entry has a
 \addtoindexx{specification attribute}
 referencing the debugging information entry
 owned by the body of the structure, union or class entry and
-representing a non\dash defining declaration of the data, function
+representing a non-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
 for function members, location descriptions for data members)
@@ -916,8 +928,8 @@ A structure type, union type or class type entry may have a
 whose value indicates whether a value of the type should be passed by reference 
 or passed by value. The set of calling convention codes for use with types 
 \addtoindexx{calling convention codes!for types}
-\hypertarget{chap:DWATcallingconventionfortypes}{}
-is given in Table \referfol{tab:callingconventioncodesfortypes}.
+is\hypertarget{chap:DWATcallingconventionfortypes}{}
+given in Table \referfol{tab:callingconventioncodesfortypes}.
 
 \begin{simplenametable}[2.2in]{Calling convention codes for types}{tab:callingconventioncodesfortypes}
 \DWCCnormal             \\
@@ -957,8 +969,8 @@ An interface type entry has
 a \DWATname{} attribute,
 \addtoindexx{name attribute}
 whose
-value is a null\dash terminated string containing the type name
-as it appears in the source program.
+value is a null\dash terminated string containing the type name.
+\bbeb
 
 The members of an interface are represented by debugging
 information entries that are owned by the interface type
@@ -1006,10 +1018,9 @@ a reference to the debugging information entry describing the
 class or interface from which the parent class or structure
 of the inheritance entry is derived, extended or implementing.
 
-An inheritance entry 
-\addtoindexx{inheritance entry}
+An\hypertarget{chap:DWATdatamemberlocationinheritedmemberlocation}{} 
+inheritance entry\addtoindexx{inheritance entry}
 for a class that derives from or extends
-\hypertarget{chap:DWATdatamemberlocationinheritedmemberlocation}{}
 another class or struct also has a 
 \DWATdatamemberlocationDEFN{} attribute, 
 \addtoindexx{data member location attribute}
@@ -1029,25 +1040,24 @@ inherited types is the same as the interpretation for data
 members 
 (see Section \referfol{chap:datamemberentries}).  }
 
-An 
+An\hypertarget{chap:DWATaccessibilitycppinheritedmembers}{} 
 \addtoindexx{inheritance entry}
-inheritance entry 
-\hypertarget{chap:DWATaccessibilitycppinheritedmembers}{}
-may 
-\addtoindexx{accessibility attribute}
-have a
-\DWATaccessibilityDEFN{}
-attribute. 
+inheritance entry may have a
+\bb
+\hyperlink{chap:DWATaccessibilityattribute}{\DWATaccessibilityNAME}
+\eb
+attribute.\addtoindexx{accessibility 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 struct, union or interface.
 
-If\hypertarget{chap:DWATvirtualityvirtualityofbaseclass}{}
-the class referenced by the 
-\addtoindexx{inheritance entry}
-inheritance entry serves
-as a \addtoindex{C++} virtual base class, the inheritance entry has a
-\DWATvirtualityDEFN{} attribute.
+If the class referenced by the \addtoindex{inheritance entry}
+serves as a \addtoindex{C++} virtual base class, the 
+inheritance entry has a 
+\bb
+\hyperlink{chap:DWATvirtualityvirtualityindication}{\DWATvirtualityNAME} 
+\eb
+attribute.
 
 \textit{For a \addtoindex{C++} virtual base, the 
 \addtoindex{data member location attribute}
@@ -1058,7 +1068,6 @@ will usually consist of a non-trivial
 \label{chap:accessdeclarations}
 
 \textit{In \addtoindex{C++}, a derived class may contain access declarations that
-\addtoindexx{access declaration entry}
 change the accessibility of individual class members from the
 overall accessibility specified by the inheritance declaration.
 A single access declaration may refer to a set of overloaded
@@ -1066,35 +1075,32 @@ names.}
 
 If a derived class or structure contains access declarations,
 each such declaration may be represented by a debugging
-information entry with the tag 
-\DWTAGaccessdeclarationTARG. 
-Each
-such entry is a child of the class or structure type entry.
-
-An access declaration entry has 
-a \DWATname{} attribute, 
-\addtoindexx{name attribute}
-whose
-value is a null\dash terminated string representing the name used
-in the declaration in the source program, including any class
-or structure qualifiers.
-
-An access declaration entry 
-\hypertarget{chap:DWATaccessibilitycppbaseclasses}{}
-also 
-has a 
-\DWATaccessibilityDEFN{}
-attribute describing the declared accessibility of the named
-entities.
+information entry with the tag \DWTAGaccessdeclarationTARG.
+\addtoindexx{access declaration entry}
+Each such entry is a child of the class or structure type entry.
+
+An access declaration entry has a \DWATname{} attribute, 
+whose value is a null-terminated string representing the name 
+used in the declaration,
+\bbeb
+including any class or structure qualifiers.
+
+An\hypertarget{chap:DWATaccessdeclaration}{} 
+access declaration entry also has a
+\bb 
+\hyperlink{chap:DWATaccessibilityattribute}{\DWATaccessibilityNAME}
+\eb
+\addtoindexx{accessibility attribute}
+attribute describing the declared accessibility of the named entities.
 
 
 \needlines{6}
 \subsection{Friends}
 \label{chap:friends}
 
-Each friend\addtoindexx{friend entry}
+Each\hypertarget{chap:DWATfriendfriendrelationship}{} 
+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.
@@ -1117,29 +1123,33 @@ member entry for a named member has
 a \DWATname{} attribute 
 \addtoindexx{name attribute}
 whose value is a null\dash terminated
-string containing the member name as it appears in the source
-program. If the member entry describes an 
+string containing the member name.
+\bbeb
+If the member entry describes an 
 \addtoindex{anonymous union},
 the name attribute is omitted or the value of the attribute
 consists of a single zero byte.
 
 The data member entry has a 
+\bb
 \DWATtype{} attribute\addtoindexx{type attribute} to denote
+\eb
 \addtoindexx{member entry (data)} the type of that member.
 
-A data member entry may have a \DWATaccessibility{}
+A data member entry may have a 
+\bb
+\hyperlink{chap:DWATaccessibilityattribute}{\DWATaccessibilityNAME}
+\eb
 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}{}
-entry 
-\addtoindexx{member entry (data)}
-may 
+A\hypertarget{chap:DWATmutablemutablepropertyofmemberdata}{}
+data member entry \addtoindexx{member entry (data)}
+may have a 
 \addtoindexx{mutable attribute}
-have a \DWATmutableDEFN{} attribute,
+\DWATmutableDEFN{} attribute,
 which is a \livelink{chap:classflag}{flag}. 
 This attribute indicates whether the data
 member was declared with the mutable storage class specifier.
@@ -1155,15 +1165,12 @@ address. When the storage for an entity includes all of
 the bits in the beginning byte, the beginning bit offset is
 defined to be zero.
 
-Bit offsets in DWARF use the bit numbering and direction
-conventions that are appropriate to the current language on
-the target system.
+\bbpareb
 
-The member entry 
-\addtoindexx{member entry (data)}
+The\hypertarget{chap:DWATdatabitoffsetdatamemberbitlocation}{}
+member\hypertarget{chap:DWATdatamemberlocationdatamemberlocation}{} 
+entry \addtoindexx{member entry (data)}
 corresponding to a data member that is defined
-\hypertarget{chap:DWATdatabitoffsetdatamemberbitlocation}{}
-\hypertarget{chap:DWATdatamemberlocationdatamemberlocation}{}
 in a structure, union or class may have either a 
 \DWATdatamemberlocationDEFN{} attribute
 \addtoindexx{data member location attribute}
@@ -1249,7 +1256,7 @@ with the
 tag \DWTAGsubprogram.
 The member function entry
 may contain the same attributes and follows the same rules
-as non\dash member global subroutine entries 
+as non-member global subroutine entries 
 (see Section \refersec{chap:subroutineandentrypointentries}).
 
 \needlines{4}
@@ -1259,30 +1266,28 @@ same rules as function template instantiations (see Section
 \refersec{chap:functiontemplateinstantiations}).
 }
 
-A 
+A member function entry may have a 
+\hyperlink{chap:DWATaccessibilityattribute}{\DWATaccessibilityNAME}
 \addtoindexx{accessibility attribute}
-member function entry may 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.
 
-If 
-\hypertarget{chap:DWATvirtualityvirtualityoffunction}{}
-the member function entry describes a virtual function,
-then that entry has a 
-\DWATvirtualityDEFN{} attribute.
+If the member function entry describes a virtual function,
+then that entry has a
+\bb
+\hyperlink{chap:DWATvirtualityvirtualityindication}{\DWATvirtualityNAME} 
+\eb
+attribute.
 
-If 
-\hypertarget{chap:DWATexplicitexplicitpropertyofmemberfunction}{}
+If\hypertarget{chap:DWATexplicitexplicitpropertyofmemberfunction}{}
 the member function entry describes an explicit member
 function, then that entry has 
 \addtoindexx{explicit attribute}
 a 
 \DWATexplicitDEFN{} attribute.
 
-An 
-\hypertarget{chap:DWATvtableelemlocationvirtualfunctiontablevtableslot}{}
+An\hypertarget{chap:DWATvtableelemlocationvirtualfunctiontablevtableslot}{}
 entry for a virtual function also has a
 \DWATvtableelemlocationDEFN{}
 \addtoindexi{attribute}{vtable element location attribute} whose value contains
@@ -1293,9 +1298,8 @@ enclosing class. The address of an object of the enclosing
 type is pushed onto the expression stack before the location
 description is evaluated.
 
-If 
-\hypertarget{chap:DWATobjectpointerobjectthisselfpointerofmemberfunction}{}
-the member function entry describes a non\dash static member
+If\hypertarget{chap:DWATobjectpointerobjectthisselfpointerofmemberfunction}{}
+the member function entry describes a non-static member
 \addtoindexx{this pointer attribute|see{object pointer attribute}}
 function, then that entry 
 \addtoindexx{self pointer attribute|see{object pointer attribute}}
@@ -1313,23 +1317,25 @@ and some other languages). That parameter
 also has a \DWATartificial{} attribute whose value is true.
 
 Conversely, if the member function entry describes a static
-member function, the entry does not have 
+member function, the entry does not have a
 \addtoindexx{object pointer attribute}
-a 
-\DWATobjectpointer{}
-attribute.
+\DWATobjectpointer{} attribute.
 
 \textit{In \addtoindex{C++}, non-static member functions can have const-volatile
 qualifiers, which affect the type of the first formal parameter (the
 \doublequote{\texttt{this}}-pointer).}
  
-If the member function entry describes a non\dash static member
+If the member function entry describes a non-static member
 function that has a const\dash volatile qualification, then
-the entry describes a non\dash static member function whose
+the entry describes a non-static member function whose
 object formal parameter has a type that has an equivalent
-const\dash volatile qualification.
+const-volatile qualification.
 
-\textit{Beginning in \addtoindex{C++:2011 (ISO)}, non-static member 
+\textit{Beginning in 
+\bb
+\addtoindex{C++11}, 
+\eb
+non-static member 
 functions can also have one of the ref-qualifiers, \& and \&\&. 
 These do not change the type of the
 \doublequote{\texttt{this}}-pointer, but they do affect the types of 
@@ -1344,8 +1350,9 @@ lvalue objects, or the \DWATrvaluereferenceDEFN{} attribute
 to indicate that it can only be called on prvalues and xvalues.
 
 \textit{The lvalue, prvalue and xvalue concepts are defined in the
-\addtoindex{C++:2011} and later standards and not repeated or
-considered further in DWARF.}
+\bb
+\addtoindex{C++11} and later standards.}
+\eb
 
 If a subroutine entry represents the defining declaration
 of a member function and that definition appears outside of
@@ -1473,14 +1480,12 @@ information entry\addtoindexx{variant part entry} with the
 tag \DWTAGvariantpartTARG{} and is
 owned by the corresponding structure type entry.
 
-If the variant part has a discriminant, the discriminant is
-\hypertarget{chap:DWATdiscrdiscriminantofvariantpart}{}
-represented by a 
-\addtoindexx{discriminant (entry)}
+If the variant part has a discriminant, the discriminant 
+is\hypertarget{chap:DWATdiscrdiscriminantofvariantpart}{}
+represented by a \addtoindexx{discriminant (entry)}
 separate debugging information entry which
 is a child of the variant part entry. This entry has the form
-of a 
-\addtoindexx{member entry (data)!as discriminant}
+of a \addtoindexx{member entry (data)!as discriminant}
 structure data member entry. The variant part entry will
 have a 
 \DWATdiscrDEFN{} attribute \addtoindexx{discriminant attribute}
@@ -1488,14 +1493,12 @@ whose value is a \livelink{chap:classreference}{reference} to
 the member entry for the discriminant.
 
 If the variant part does not have a discriminant (tag field),
-the variant part entry has 
-\addtoindexx{type attribute}
-a 
-\DWATtype{} attribute to represent
+the variant part entry has \addtoindexx{type attribute}
+a \DWATtype{} attribute to represent
 the tag type.
 
-Each variant of a particular variant part is represented by
-\hypertarget{chap:DWATdiscrvaluediscriminantvalue}{}
+Each variant of a particular variant part is represented 
+by\hypertarget{chap:DWATdiscrvaluediscriminantvalue}{}
 a debugging information entry\addtoindexx{variant entry} with the 
 tag \DWTAGvariantTARG{}
 and is a child of the variant part entry. The value that
@@ -1510,11 +1513,10 @@ is a signed type. The number is unsigned if the tag type is
 an unsigned type.
 
 \needlines{5}
-Alternatively, 
-\hypertarget{chap:DWATdiscrlistlistofdiscriminantvalues}{}
-the variant entry may contain 
+Alternatively,\hypertarget{chap:DWATdiscrlistlistofdiscriminantvalues}{}
+the variant entry may contain a
 \addtoindexx{discriminant list attribute}
-\DWATdiscrlistDEFN{}
+\DWATdiscrlistDEFN{}
 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 
@@ -1522,9 +1524,8 @@ 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 
+represented as an LEB128 number as defined above for the
 \addtoindexx{discriminant value attribute}
-the
 \DWATdiscrvalue{} 
 attribute. A label range is represented by
 two LEB128 numbers, the low value of the range followed by the
@@ -1573,7 +1574,8 @@ has been given to the condition, the condition entry has a
 \DWATname{} attribute
 \addtoindexx{name attribute}
 whose value is a null\dash terminated string
-giving the condition name as it appears in the source program.
+giving the condition name.
+\bbeb
 
 \needlines{4}
 The condition entry's parent entry describes the conditional
@@ -1626,8 +1628,8 @@ program, then the corresponding enumeration type entry has
 a \DWATname{} attribute
 \addtoindexx{name attribute}
 whose value is a null\dash terminated
-string containing the enumeration type name as it appears
-in the source program. 
+string containing the enumeration type name.
+\bbeb
 
 The \addtoindex{enumeration type entry}
 may have 
@@ -1662,8 +1664,8 @@ required.
 
 \textit{In \addtoindex{C} or \addtoindex{C++}, 
 the underlying type will be the appropriate
-integral type determined by the compiler from the properties of
-\hypertarget{chap:DWATenumclasstypesafeenumerationdefinition}{}
+integral type determined by the compiler from the properties 
+of\hypertarget{chap:DWATenumclasstypesafeenumerationdefinition}{}
 the enumeration literal values. 
 A \addtoindex{C++} type declaration written
 using enum class declares a strongly typed enumeration and
@@ -1683,9 +1685,10 @@ of the enumeration literals in the source program.
 \needlines{4}
 Each \addtoindex{enumerator entry} has a \DWATname{} attribute, whose
 \addtoindexx{name attribute}
-value is a null-terminated string containing the name of the
-\hypertarget{chap:DWATconstvalueenumerationliteralvalue}{}
-enumeration literal as it appears in the source program. 
+value is a null-terminated string containing the name of 
+the\hypertarget{chap:DWATconstvalueenumerationliteralvalue}{}
+enumeration literal.
+\bbeb
 Each enumerator entry also has a 
 \DWATconstvalueDEFN{} attribute,
 \addtoindexx{constant value attribute}
@@ -1694,26 +1697,21 @@ 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
-\hypertarget{chap:DWATbytestrideenumerationstridedimensionofarraytype}{}
-is different than what would otherwise be determined, then
-\hypertarget{chap:DWATbitstrideenumerationstridedimensionofarraytype}{}
-the enumeration type entry has either a 
-\DWATbytestrideDEFN{}
-or \DWATbitstrideDEFN{} attribute 
+dimension of an array type, and the stride for that 
+dimension\hypertarget{chap:DWATbytestrideenumerationstridedimensionofarraytype}{}
+is different than what would otherwise be determined, 
+then\hypertarget{chap:DWATbitstrideenumerationstridedimensionofarraytype}{}
+the enumeration type entry has either a
+\addtoindexx{byte stride attribute} 
+\DWATbytestrideDEFN{} or
 \addtoindexx{bit stride attribute}
-which specifies the separation
+\DWATbitstrideDEFN{} attribute which specifies the separation
 between successive elements along the dimension as described
-in 
-Section \refersec{chap:staticanddynamicvaluesofattributes}. 
-The value of the 
-\DWATbitstride{} attribute
-\addtoindexx{bit stride attribute}
-is interpreted as bits and the value of 
-\addtoindexx{byte stride attribute}
-the 
-\DWATbytestride{}
-attribute is interpreted as bytes.
+in Section \refersec{chap:staticanddynamicvaluesofattributes}. 
+The value of the \DWATbitstride{} attribute
+is interpreted as bits and 
+the value of the \DWATbytestride{} attribute is interpreted 
+as bytes.
 
 
 \section{Subroutine Type Entries}
@@ -1740,12 +1738,13 @@ then the corresponding subroutine type entry has
 a \DWATname{} attribute 
 \addtoindexx{name attribute}
 whose value is a null\dash terminated string containing
-the subroutine type name as it appears in the source program.
+the subroutine type name.
+\bbeb
 
 If the subroutine type describes a function that returns
-a value, then the subroutine type entry has 
+a value, then the subroutine type entry has a
 \addtoindexx{type attribute}
-\DWATtype{}
+\DWATtype{}
 attribute to denote the type returned by the subroutine. If
 the types of the arguments are necessary to describe the
 subroutine type, then the corresponding subroutine type
@@ -1757,7 +1756,7 @@ source program.
 \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-prototype declarations.}
 
 A 
 \hypertarget{chap:DWATprototypedsubroutineprototype}{}
@@ -1793,8 +1792,11 @@ tag \DWTAGunspecifiedparameters.
 
 \textit{\addtoindex{C++} const-volatile qualifiers are encoded as 
 part of the type of the
-\doublequote{\texttt{this}}-pointer. 
-\addtoindex{C++:2011 (ISO)} reference and rvalue-reference qualifiers are encoded using
+\doublequote{\texttt{this}}-pointer.
+\bb 
+\addtoindex{C++11} 
+\eb
+reference and rvalue-reference qualifiers are encoded using
 the \DWATreference{} and \DWATrvaluereference{} attributes, respectively. 
 See also Section \refersec{chap:memberfunctionentries}.}
 
@@ -1824,12 +1826,11 @@ the string type in the source program, then the corresponding
 string type entry has a 
 \DWATname{} attribute
 \addtoindexx{name attribute}
-whose value is
-a null\dash terminated string containing the string type name as
-it appears in the source program.
+whose value is a null-terminated string containing the string type name.
+\bbeb
 
 A string type entry may have a \DWATtypeDEFN{} 
-\livetargi{char:DWAATtypeofstringtype}{attribute}{type attribute!of string type entry}
+\livetargi{chap:DWAATtypeofstringtype}{attribute}{type attribute!of string type entry}
 describing how each character is encoded and is to be interpreted.  
 The value of this attribute is a \CLASSreference{} to a 
 \DWTAGbasetype{} base type entry.  If the attribute is absent, 
@@ -1855,8 +1856,7 @@ attribute, whose value
 is the amount of
 storage needed to hold a value of the string type.
 
-The 
-\hypertarget{chap:DWATstringlengthstringlengthofstringtype}{}
+The\hypertarget{chap:DWATstringlengthstringlengthofstringtype}{}
 string type entry may also have a 
 \DWATstringlengthDEFN{} attribute
 whose 
@@ -1912,11 +1912,12 @@ set type, then the set type entry has
 a \DWATname{} attribute
 \addtoindexx{name attribute}
 whose value is a null\dash terminated string containing the
-set type name as it appears in the source program.
+set type name.
+\bbeb
 
-The set type entry has 
+The set type entry has a
 \addtoindexx{type attribute}
-\DWATtype{} attribute to denote the
+\DWATtype{} attribute to denote the
 type of an element of the set.
 
 \needlines{4}
@@ -1945,8 +1946,8 @@ 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.
+string containing the subrange type name.
+\bbeb
 
 The tag \DWTAGgenericsubrange{}
 is used to describe arrays with a dynamic rank. See Section
@@ -1968,8 +1969,7 @@ attribute, whose value
 (see Section \refersec{chap:staticanddynamicvaluesofattributes})
 is the amount of storage needed to hold a value of the subrange type.
 
-The 
-\hypertarget{chap:DWATthreadsscaledupcarrayboundthreadsscalfactor}{}
+The\hypertarget{chap:DWATthreadsscaledupcarrayboundthreadsscalfactor}{}
 subrange entry may have a 
 \DWATthreadsscaledDEFN{} attribute\addtoindexx{threads scaled attribute},
 which is a \livelink{chap:classflag}{flag}. 
@@ -1985,18 +1985,16 @@ int shared foo[34*THREADS][10][20];
 \end{lstlisting}
 
 \needlines{4}
-The 
-\hypertarget{chap:DWATlowerboundlowerboundofsubrange}{}
-subrange 
-\hypertarget{chap:DWATupperboundupperboundofsubrange}{}
+The\hypertarget{chap:DWATlowerboundlowerboundofsubrange}{}
+subrange\hypertarget{chap:DWATupperboundupperboundofsubrange}{}
 entry may have the attributes 
 \DWATlowerboundDEFN{}
 \addtoindexx{lower bound attribute}
 and \DWATupperboundDEFN{}
 \addtoindexx{upper bound attribute} to specify, respectively, the lower
 and upper bound values of the subrange. The 
-\DWATupperboundNAME{} attribute 
-\hypertarget{chap:DWATcountelementsofsubrangetype}{}
+\DWATupperboundNAME{} 
+attribute\hypertarget{chap:DWATcountelementsofsubrangetype}{}
 may be replaced by a
 \addtoindexx{count attribute!default}
 \addtoindexx{count attribute}
@@ -2031,13 +2029,12 @@ integer with the same size as an address on the target machine.
 \end{enumerate}
 
 If the subrange type occurs as the description of a dimension
-of an array type, and the stride for that dimension is
-\hypertarget{chap:DWATbytestridesubrangestridedimensionofarraytype}{}
-different than what would otherwise be determined, then
-\hypertarget{chap:DWATbitstridesubrangestridedimensionofarraytype}{}
-the subrange type entry has either 
+of an array type, and the stride for that dimension 
+is\hypertarget{chap:DWATbytestridesubrangestridedimensionofarraytype}{}
+different than what would otherwise be determined, 
+then\hypertarget{chap:DWATbitstridesubrangestridedimensionofarraytype}{}
+the subrange type entry has either a
 \addtoindexx{byte stride attribute}
-a 
 \DWATbytestrideDEFN{} or
 \DWATbitstrideDEFN{} attribute 
 \addtoindexx{bit stride attribute}
@@ -2065,8 +2062,8 @@ pointer to member entry has a
 \DWATname{} attribute, 
 \addtoindexx{name attribute}
 whose value is a
-null\dash terminated string containing the type name as it appears
-in the source program.
+null\dash terminated string containing the type name.
+\bbeb
 
 The \addtoindex{pointer to member} entry 
 has 
@@ -2075,17 +2072,16 @@ a \DWATtype{} attribute to
 describe the type of the class or structure member to which
 objects of this type may point.
 
-The \addtoindexx{pointer to member} entry also 
-\hypertarget{chap:DWATcontainingtypecontainingtypeofpointertomembertype}{}
+The \addtoindexx{pointer to member} entry 
+also\hypertarget{chap:DWATcontainingtypecontainingtypeofpointertomembertype}{}
 has a \DWATcontainingtypeDEFN{} attribute, 
 \addtoindexx{containing type (of pointer) attribute}
 whose value is a \livelink{chap:classreference}{reference} to a debugging
 information entry for the class or structure to whose members
 objects of this type may point.
 
-The \addtoindex{pointer to member entry} 
-\hypertarget{chap:DWATuselocationmemberlocationforpointertomembertype}{}
-has a 
+The\hypertarget{chap:DWATuselocationmemberlocationforpointertomembertype}{}
+\addtoindex{pointer to member entry} has a 
 \DWATuselocationDEFN{} attribute
 \addtoindexx{use location attribute}
 whose value is a 
@@ -2147,8 +2143,8 @@ If the file type has a name,
 the file type entry has a \DWATname{} attribute,
 \addtoindexx{name attribute}
 whose value
-is a null\dash terminated string containing the type name as it
-appears in the source program.
+is a null\dash terminated string containing the type name.
+\bbeb 
 
 The file type entry has 
 \addtoindexx{type attribute}
@@ -2180,7 +2176,8 @@ A dynamic type is represented by a debugging information entry
 with the tag \DWTAGdynamictypeTARG. If a name has been given to the
 dynamic type, then the dynamic type has a \DWATname{} attribute 
 whose value is a null-terminated string containing the dynamic
-type name as it appears in the source.
+type name.
+\bbeb
        
 A dynamic type entry has a \DWATtype{} attribute whose value is a
 reference to the type of the entities that are dynamically allocated.
@@ -2210,8 +2207,8 @@ 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.
+containing the name of the template alias.
+\bbeb 
 The template alias entry has child entries describing the template
 actual parameters (see Section \refersec{chap:templateparameters}).
 
@@ -2230,8 +2227,8 @@ attributes described in this section are motivated for use with
 information, including a location and/or run\dash time parameters,
 about the data that represents the value for that object.}
 
-\hypertarget{chap:DWATdatalocationindirectiontoactualdata}{}
-The \DWATdatalocationDEFN{} attribute 
+The\hypertarget{chap:DWATdatalocationindirectiontoactualdata}{}
+\DWATdatalocationDEFN{} attribute 
 \addtoindexx{data (indirect) location attribute}
 may be used with any type that provides one or more levels of 
 \addtoindexx{hidden indirection|see{data location attribute}}
@@ -2261,19 +2258,17 @@ provide types whose values
 may be dynamically allocated or associated with a variable
 under explicit program control.}
 
-\hypertarget{chap:DWATallocatedallocationstatusoftypes}{}
-The \DWATallocatedDEFN{} attribute\addtoindexx{allocated attribute}
+The\hypertarget{chap:DWATallocatedallocationstatusoftypes}{}
+\DWATallocatedDEFN{} 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
 integer value of the attribute (see below) specifies whether
-an object of the type is 
-currently allocated or not.
+an object of the type is currently allocated or not.
 
 \needlines{4}
-\hypertarget{chap:DWATassociatedassociationstatusoftypes}{}
-The 
+The\hypertarget{chap:DWATassociatedassociationstatusoftypes}{} 
 \DWATassociatedDEFN{} attribute 
 may 
 \addtoindexx{associated attribute}
@@ -2286,8 +2281,8 @@ an object of the type is currently associated or not.
 
 The value of these attributes is determined as described in
 Section \refersec{chap:staticanddynamicvaluesofattributes}.
-
-A non\dash zero value is interpreted as allocated or associated,
+\bbeb
+A non-zero value is interpreted as allocated or associated,
 and zero is interpreted as not allocated or not associated.
 
 \textit{For \addtoindex{Fortran 90}, 
@@ -2320,8 +2315,8 @@ see Appendix \refersec{app:aggregateexamples}.}
   at compile time. The Fortran runtime stores the rank in an array
   descriptor.}
 
-The presence of the
-\hypertarget{chap:DWATrankofdynamicarray}{\DWATrankINDX}
+The presence of 
+the\hypertarget{chap:DWATrankofdynamicarray}{\DWATrankINDX}
 attribute indicates that an array's rank
 (number of dimensions) is dynamic, and therefore unknown at compile
 time. The value of the \DWATrankDEFN{} attribute is either an integer constant