Changes from review comments and July 15 meeting, except changes
authorRon Brender <ron.brender@gmail.com>
Tue, 22 Jul 2014 15:36:07 +0000 (11:36 -0400)
committerRon Brender <ron.brender@gmail.com>
Tue, 22 Jul 2014 15:36:07 +0000 (11:36 -0400)
for line number headers (140323.1 and 140331.2).

Signed-off-by: Ron Brender <ron.brender@gmail.com>
12 files changed:
dwarf5/latexdoc/changesummary.tex
dwarf5/latexdoc/compression.tex
dwarf5/latexdoc/copyright.tex
dwarf5/latexdoc/datarepresentation.tex
dwarf5/latexdoc/dwarf5.tex
dwarf5/latexdoc/dwarfnamecmds.tex
dwarf5/latexdoc/examples.tex
dwarf5/latexdoc/generaldescription.tex
dwarf5/latexdoc/introduction.tex
dwarf5/latexdoc/otherdebugginginformation.tex
dwarf5/latexdoc/programscope.tex
dwarf5/latexdoc/typeentries.tex

index 6f72960..75dd816 100644 (file)
@@ -15,6 +15,9 @@ 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
 \begin{longtable}{ll}
 \textbf{Date}  & \textbf{Issue Incorporated or Other Change}   \\ \hline       \\
 \endhead
+7/22/2014       & Add items in Section 1.4, Changes from Version 4 to Version 5 \\
+7/21/2014       & Enable section numbers on pdf bookmarks \\
+7/20/2014       & 140425.1 (typed stack), 140707.1 (Dylan language), review comments \\ 
 6/17/2014       & 140506.1 (correct DWARF error in member function example), \\
                 & 140602.1 (Swift language), 140606.1 (Julia language), \\
                 & 140421.1 (DWARF package files), all review comments to date \\
 6/17/2014       & 140506.1 (correct DWARF error in member function example), \\
                 & 140602.1 (Swift language), 140606.1 (Julia language), \\
                 & 140421.1 (DWARF package files), all review comments to date \\
index a985b5c..7a07e7d 100644 (file)
@@ -254,7 +254,7 @@ corresponding to file wa.h
 above is given the name \texttt{my.compiler.company.cpp.wa.h.123456}.
 
 
 above is given the name \texttt{my.compiler.company.cpp.wa.h.123456}.
 
 
-
+\needlines{4}
 \textbf{Debugging Information Entry Names}
 
 Global labels for 
 \textbf{Debugging Information Entry Names}
 
 Global labels for 
index adcbe91..09150a7 100644 (file)
@@ -48,8 +48,8 @@ or implied warranty.
 
 \end{myindentpara}
 
 
 \end{myindentpara}
 
-This document is further based on the \dwf, Version 3, which
-is subject to the GNU Free Documentation License.
+This document is further based on the \dwf, Version 3 and
+Version 4, which are subject to the GNU Free Documentation License.
 
 Trademarks:
 \begin{itemize}
 
 Trademarks:
 \begin{itemize}
index ea74431..b9cda16 100644 (file)
@@ -640,21 +640,21 @@ enumeration are shown in Table \refersec{tab:unitheaderunitkindencodings}.
 \needlines{6}
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \needlines{6}
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
-\begin{longtable}{l|l}
-  \caption{Unit header unit kind encodings}
+\begin{longtable}{l|c}
+  \caption{Unit header unit type encodings}
   \label{tab:unitheaderunitkindencodings}
   \label{tab:unitheaderunitkindencodings}
-  \addtoindexx{Unit header unit kind encodings} \\
-  \hline \bfseries Unit header unit kind encodings&\bfseries Value \\ \hline
+  \addtoindexx{Unit header unit type encodings} \\
+  \hline \bfseries Unit header unit type encodings&\bfseries Value \\ \hline
 \endfirsthead
 \endfirsthead
-  \bfseries Unit header unit kind encodings&\bfseries Value \\ \hline
+  \bfseries Unit header unit type encodings&\bfseries Value \\ \hline
 \endhead
   \hline \emph{Continued on next page}
 \endfoot
 \endhead
   \hline \emph{Continued on next page}
 \endfoot
-  \hline
+  \hline \ddag\ \textit{New in DWARF Version 5}
 \endlastfoot
 \endlastfoot
-\DWUTcompileTARG    &0x01 \\ 
-\DWUTtypeTARG       &0x02 \\ 
-\DWUTpartialTARG    &0x03 \\ \hline
+\DWUTcompileTARG~\ddag    &0x01 \\ 
+\DWUTtypeTARG~\ddag       &0x02 \\ 
+\DWUTpartialTARG~\ddag    &0x03 \\ \hline
 \end{longtable}
 \end{centering}
 
 \end{longtable}
 \end{centering}
 
@@ -852,7 +852,7 @@ Table \refersec{tab:tagencodings}.
 
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
-\begin{longtable}{l|l}
+\begin{longtable}{l|c}
   \hline
   \caption{Tag encodings} \label{tab:tagencodings} \\
   \hline \bfseries Tag name&\bfseries Value\\ \hline
   \hline
   \caption{Tag encodings} \label{tab:tagencodings} \\
   \hline \bfseries Tag name&\bfseries Value\\ \hline
@@ -955,7 +955,7 @@ each chain of sibling entries is terminated by a null entry.)
 \needlines{6}
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \needlines{6}
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
-\begin{longtable}{l|l}
+\begin{longtable}{l|c}
   \caption{Child determination encodings}
   \label{tab:childdeterminationencodings}
   \addtoindexx{Child determination encodings} \\
   \caption{Child determination encodings}
   \label{tab:childdeterminationencodings}
   \addtoindexx{Child determination encodings} \\
@@ -1419,7 +1419,7 @@ Table \refersec{tab:attributeformencodings}.
 
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
-\begin{longtable}{l|l|l}
+\begin{longtable}{l|c|l}
   \caption{Attribute encodings} 
   \label{tab:attributeencodings} 
   \addtoindexx{attribute encodings} \\
   \caption{Attribute encodings} 
   \label{tab:attributeencodings} 
   \addtoindexx{attribute encodings} \\
@@ -1726,7 +1726,7 @@ Table \refersec{tab:attributeformencodings}.
 \needlines{8}
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \needlines{8}
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
-\begin{longtable}{l|l|l}
+\begin{longtable}{l|c|l}
   \caption{Attribute form encodings} \label{tab:attributeformencodings} \\
   \hline \bfseries Form name&\bfseries Value &\bfseries Classes \\ \hline
 \endfirsthead
   \caption{Attribute form encodings} \label{tab:attributeformencodings} \\
   \hline \bfseries Form name&\bfseries Value &\bfseries Classes \\ \hline
 \endfirsthead
@@ -1838,7 +1838,7 @@ gives algorithms for encoding and decoding these forms.}
 \needlines{8}
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \needlines{8}
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
-\begin{longtable}{l|l|l}
+\begin{longtable}{c|c|c}
   \caption{Examples of unsigned LEB128 encodings}
   \label{tab:examplesofunsignedleb128encodings} 
   \addtoindexx{LEB128 encoding!examples}\addtoindexx{LEB128!unsigned} \\
   \caption{Examples of unsigned LEB128 encodings}
   \label{tab:examplesofunsignedleb128encodings} 
   \addtoindexx{LEB128 encoding!examples}\addtoindexx{LEB128!unsigned} \\
@@ -1863,7 +1863,7 @@ gives algorithms for encoding and decoding these forms.}
 
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
-\begin{longtable}{l|l|l}
+\begin{longtable}{c|c|c}
   \caption{Examples of signed LEB128 encodings} 
   \label{tab:examplesofsignedleb128encodings} 
   \addtoindexx{LEB128!signed} \\
   \caption{Examples of signed LEB128 encodings} 
   \label{tab:examplesofsignedleb128encodings} 
   \addtoindexx{LEB128!signed} \\
@@ -2004,8 +2004,19 @@ Table \refersec{tab:dwarfoperationencodings}.
                               &&&SLEB128 constant offset \\
 \DWOPaddrx~\ddag&0xa1&1&ULEB128 indirect address \\
 \DWOPconstx~\ddag&0xa2&1&ULEB128 indirect constant   \\
                               &&&SLEB128 constant offset \\
 \DWOPaddrx~\ddag&0xa1&1&ULEB128 indirect address \\
 \DWOPconstx~\ddag&0xa2&1&ULEB128 indirect constant   \\
-\DWOPentryvalue~\ddag&0xa3&2&ULEV128 size, \\*
+\DWOPentryvalue~\ddag&0xa3&2&ULEB128 size, \\*
                    &&&\nolink{block} of that size\\
                    &&&\nolink{block} of that size\\
+\DWOPconsttype~\ddag    & 0xa4 & 3 & ULEB128 type entry offset,\\*
+                               & & & 1-byte size, \\*
+                               & & & constant value \\
+\DWOPregvaltype~\ddag   & 0xa5 & 2 & ULEB128 register number, \\*
+                                 &&& ULEB128 constant offset \\
+\DWOPdereftype~\ddag    & 0xa6 & 2 & 1-byte size, \\*
+                                 &&& ULEB128 type entry offset \\
+\DWOPxdereftype~\ddag   & 0xa7 & 2 & 1-byte size, \\*
+                                 &&& ULEB128 type entry offset \\
+\DWOPconvert~\ddag      & 0xa8 & 1 & ULEB128 type entry offset \\
+\DWOPreinterpret~\ddag  & 0xa9 & 1 & ULEB128 type entry offset \\
 \DWOPlouser{} &0xe0 && \\
 \DWOPhiuser{} &\xff && \\
 
 \DWOPlouser{} &0xe0 && \\
 \DWOPhiuser{} &\xff && \\
 
@@ -2336,6 +2347,7 @@ defined language.
 \DWLANGCeleven{} \ddag &0x001d &0 \addtoindexx{C:2011 (ISO)}\\
 \DWLANGSwift{} \ddag &0x001e &0 \addtoindexx{Swift} \\
 \DWLANGJulia{} \ddag &0x001f &1 \addtoindexx{Julia} \\
 \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} \\
 \DWLANGlouser{} &0x8000 & \\
 \DWLANGhiuser{} &\xffff & \\
 
 \DWLANGlouser{} &0x8000 & \\
 \DWLANGhiuser{} &\xffff & \\
 
@@ -2405,6 +2417,7 @@ Table \refersec{tab:callingconventionencodings}.
 \end{longtable}
 \end{centering}
 
 \end{longtable}
 \end{centering}
 
+\needlines{12}
 \section{Inline Codes}
 \label{datarep:inlinecodes}
 
 \section{Inline Codes}
 \label{datarep:inlinecodes}
 
@@ -2566,7 +2579,7 @@ Each set is terminated by an
 offset containing the value 0.
 
 
 offset containing the value 0.
 
 
-\needlines{6}
+\needlines{10}
 \section{Address Range Table}
 \label{datarep:addrssrangetable}
 
 \section{Address Range Table}
 \label{datarep:addrssrangetable}
 
@@ -2688,7 +2701,7 @@ Table \refersec{tab:linenumberstandardopcodeencodings}.
 \end{centering}
 
 
 \end{centering}
 
 
-\needspace{10cm}
+\needspace{6cm}
 The encodings for the extended opcodes are given in 
 \addtoindexx{line number opcodes!extended opcode encoding}
 Table \refersec{tab:linenumberextendedopcodeencodings}.
 The encodings for the extended opcodes are given in 
 \addtoindexx{line number opcodes!extended opcode encoding}
 Table \refersec{tab:linenumberextendedopcodeencodings}.
@@ -2717,7 +2730,7 @@ Table \refersec{tab:linenumberextendedopcodeencodings}.
 \end{longtable}
 \end{centering}
 
 \end{longtable}
 \end{centering}
 
-\needspace{10cm}
+\needspace{6cm}
 The encodings for the file entry format are given in 
 \addtoindexx{line number opcodes!file entry format encoding}
 Table \refersec{tab:linenumberfileentryformatencodings}.
 The encodings for the file entry format are given in 
 \addtoindexx{line number opcodes!file entry format encoding}
 Table \refersec{tab:linenumberfileentryformatencodings}.
@@ -2768,21 +2781,21 @@ Table \refersec{tab:macroinfoentrytypeencodings}.
 \endhead
   \hline \emph{Continued on next page}
 \endfoot
 \endhead
   \hline \emph{Continued on next page}
 \endfoot
-  \hline
+  \hline \ddag~\textit{New in DWARF Version 5}
 \endlastfoot
 
 \endlastfoot
 
-\DWMACROdefine              &0x01 \\
-\DWMACROundef               &0x02 \\
-\DWMACROstartfile           &0x03 \\
-\DWMACROendfile             &0x04 \\
-\DWMACROdefineindirect      &0x05 \\
-\DWMACROundefindirect       &0x06 \\
-\DWMACROtransparentinclude  &0x07 \\
-% what about 0x08 thru 0x0a??
-\DWMACROdefineindirectx     &0x0b \\
-\DWMACROundefindirectx      &0x0c \\
-\DWMACROlouser              &0xe0 \\
-\DWMACROhiuser              &\xff \\
+\DWMACROdefine~\ddag              &0x01 \\
+\DWMACROundef~\ddag               &0x02 \\
+\DWMACROstartfile~\ddag           &0x03 \\
+\DWMACROendfile~\ddag             &0x04 \\
+\DWMACROdefineindirect~\ddag      &0x05 \\
+\DWMACROundefindirect~\ddag       &0x06 \\
+\DWMACROtransparentinclude~\ddag  &0x07 \\
+\textit{Reserved}                 &0x08-0x0a \\
+\DWMACROdefineindirectx~\ddag     &0x0b \\
+\DWMACROundefindirectx~\ddag      &0x0c \\
+\DWMACROlouser~\ddag              &0xe0 \\
+\DWMACROhiuser~\ddag              &\xff \\
 
 \end{longtable}
 \end{centering}
 
 \end{longtable}
 \end{centering}
@@ -2881,6 +2894,7 @@ For a \addtoindex{range list} to be specified, the base address of the
 corresponding compilation unit must be defined 
 (see Section \refersec{chap:normalandpartialcompilationunitentries}).
 
 corresponding compilation unit must be defined 
 (see Section \refersec{chap:normalandpartialcompilationunitentries}).
 
+\needlines{6}
 \section{String Offsets Table}
 \label{chap:stringoffsetstable}
 Each set of entries in the string offsets table contained in the
 \section{String Offsets Table}
 \label{chap:stringoffsetstable}
 Each set of entries in the string offsets table contained in the
@@ -3054,10 +3068,9 @@ selector is omitted from the range list entries.
 The entries are referenced by a byte offset relative to the first
 location list following this header.
 
 The entries are referenced by a byte offset relative to the first
 location list following this header.
 
-
+\needlines{6}
 \section{Dependencies and Constraints}
 \label{datarep:dependenciesandconstraints}
 \section{Dependencies and Constraints}
 \label{datarep:dependenciesandconstraints}
-
 The debugging information in this format is intended to
 exist 
 \addtoindexx{DWARF section names!list of}
 The debugging information in this format is intended to
 exist 
 \addtoindexx{DWARF section names!list of}
@@ -3123,15 +3136,15 @@ section offset that occurs at
 an arbitrary alignment.
 \end{itemize}
 
 an arbitrary alignment.
 \end{itemize}
 
+\needlines{8}
 \section{Integer Representation Names}
 \label{datarep:integerrepresentationnames}
 \section{Integer Representation Names}
 \label{datarep:integerrepresentationnames}
-
 The sizes of the integers used in the lookup by name, lookup
 by address, line number and call frame information sections
 are given in
 Table \ref{tab:integerrepresentationnames}.
 
 The sizes of the integers used in the lookup by name, lookup
 by address, line number and call frame information sections
 are given in
 Table \ref{tab:integerrepresentationnames}.
 
-\needlines{8}
+\needlines{12}
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \begin{longtable}{c|l}
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \begin{longtable}{c|l}
@@ -3350,6 +3363,7 @@ the entry S. Exception: if a particular attribute is found in
 both S and D, the attribute in S is used and the corresponding
 one in D is ignored.
 
 both S and D, the attribute in S is used and the corresponding
 one in D is ignored.
 
+\needlines{4}
 DWARF tag and attribute codes are appended to the sequence
 as unsigned LEB128\addtoindexx{LEB128!unsigned} values, 
 using the values defined earlier in this chapter.
 DWARF tag and attribute codes are appended to the sequence
 as unsigned LEB128\addtoindexx{LEB128!unsigned} values, 
 using the values defined earlier in this chapter.
index ecb421c..c612987 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.
 %
 % 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}{June 18, 2014}
+\newcommand{\docdate}{July 22, 2014}
 %
 \usepackage{ifthen}
 \newboolean{isdraft}
 %
 \usepackage{ifthen}
 \newboolean{isdraft}
@@ -69,7 +69,7 @@ escapeinside={\%*}{*)}     % if you want to add a comment within your code
 % pdf of the index. 
 % Also, allcolors lets us generate colored active links inside a pdf.
 % And breaklinks resolves truncation issues with very long link names.
 % pdf of the index. 
 % Also, allcolors lets us generate colored active links inside a pdf.
 % And breaklinks resolves truncation issues with very long link names.
-\usepackage[breaklinks,plainpages=false,pdfpagelabels,pagebackref,allcolors=blue]{hyperref} 
+\usepackage[breaklinks,plainpages=false,pdfpagelabels,pagebackref,allcolors=blue,bookmarksnumbered=true]{hyperref} 
 \makeindex  % This and the makeidx package allow \index to create index entries.
 
 \newcommand{\dwf}{DWARF Debugging Information Format}
 \makeindex  % This and the makeidx package allow \index to create index entries.
 
 \newcommand{\dwf}{DWARF Debugging Information Format}
@@ -101,7 +101,7 @@ escapeinside={\%*}{*)}     % if you want to add a comment within your code
 \newcommand{\figurepart}[2]{\raggedleft{\textit{\tiny{part #1 of #2}}}}
 
 % Generate a page ref.
 \newcommand{\figurepart}[2]{\raggedleft{\textit{\tiny{part #1 of #2}}}}
 
 % Generate a page ref.
-% use like   \refersec{chap:registerbasedaddressing}
+% use like   \refersec{chap:registervalues}
 %\newcommand{\refersec}[1]{\ref{#1} on page \pageref{#1}}
 \newcommand{\refersec}[1]{\vref{#1}}  % beware possible rerun loop
 \newcommand{\referfol}[1]{\ref{#1} following}
 %\newcommand{\refersec}[1]{\ref{#1} on page \pageref{#1}}
 \newcommand{\refersec}[1]{\vref{#1}}  % beware possible rerun loop
 \newcommand{\referfol}[1]{\ref{#1} following}
@@ -311,7 +311,7 @@ escapeinside={\%*}{*)}     % if you want to add a comment within your code
 \setcounter{secnumdepth}{5}
 
 \include{introduction}
 \setcounter{secnumdepth}{5}
 
 \include{introduction}
-\include{generaldescription}            %\emptypage
+\include{generaldescription}            \emptypage
 \include{programscope}                  %\emptypage
 \include{dataobject}                    \emptypage
 \include{typeentries}                   %\emptypage
 \include{programscope}                  %\emptypage
 \include{dataobject}                    \emptypage
 \include{typeentries}                   %\emptypage
index b273634..4bdbb16 100644 (file)
 \newdwfnamecommands{DWLANGCobolseventyfour}{DW\_LANG\_Cobol74}
 \newdwfnamecommands{DWLANGCoboleightyfive}{DW\_LANG\_Cobol85}
 \newdwfnamecommands{DWLANGD}{DW\_LANG\_D}
 \newdwfnamecommands{DWLANGCobolseventyfour}{DW\_LANG\_Cobol74}
 \newdwfnamecommands{DWLANGCoboleightyfive}{DW\_LANG\_Cobol85}
 \newdwfnamecommands{DWLANGD}{DW\_LANG\_D}
+\newdwfnamecommands{DWLANGDylan}{DW\_LANG\_Dylan}
 \newdwfnamecommands{DWLANGFortranseventyseven}{DW\_LANG\_Fortran77}
 \newdwfnamecommands{DWLANGFortranninety}{DW\_LANG\_Fortran90}
 \newdwfnamecommands{DWLANGFortranninetyfive}{DW\_LANG\_Fortran95}
 \newdwfnamecommands{DWLANGFortranseventyseven}{DW\_LANG\_Fortran77}
 \newdwfnamecommands{DWLANGFortranninety}{DW\_LANG\_Fortran90}
 \newdwfnamecommands{DWLANGFortranninetyfive}{DW\_LANG\_Fortran95}
 \newdwfnamecommands{DWOPconstoneu}{DW\_OP\_const1u}
 \newdwfnamecommands{DWOPconsttwos}{DW\_OP\_const2s}
 \newdwfnamecommands{DWOPconsttwou}{DW\_OP\_const2u}
 \newdwfnamecommands{DWOPconstoneu}{DW\_OP\_const1u}
 \newdwfnamecommands{DWOPconsttwos}{DW\_OP\_const2s}
 \newdwfnamecommands{DWOPconsttwou}{DW\_OP\_const2u}
+\newdwfnamecommands{DWOPconsttype}{DW\_OP\_const\_type}
 \newdwfnamecommands{DWOPconstfours}{DW\_OP\_const4s}
 \newdwfnamecommands{DWOPconstfouru}{DW\_OP\_const4u}
 \newdwfnamecommands{DWOPconsteights}{DW\_OP\_const8s}
 \newdwfnamecommands{DWOPconstfours}{DW\_OP\_const4s}
 \newdwfnamecommands{DWOPconstfouru}{DW\_OP\_const4u}
 \newdwfnamecommands{DWOPconsteights}{DW\_OP\_const8s}
 \newdwfnamecommands{DWOPconsts}{DW\_OP\_consts}
 \newdwfnamecommands{DWOPconstu}{DW\_OP\_constu}
 \newdwfnamecommands{DWOPconstx}{DW\_OP\_constx}
 \newdwfnamecommands{DWOPconsts}{DW\_OP\_consts}
 \newdwfnamecommands{DWOPconstu}{DW\_OP\_constu}
 \newdwfnamecommands{DWOPconstx}{DW\_OP\_constx}
+\newdwfnamecommands{DWOPconvert}{DW\_OP\_convert}
 \newdwfnamecommands{DWOPderef}{DW\_OP\_deref}
 \newdwfnamecommands{DWOPderef}{DW\_OP\_deref}
+\newdwfnamecommands{DWOPdereftype}{DW\_OP\_deref\_type}
 \newdwfnamecommands{DWOPderefsize}{DW\_OP\_deref\_size}
 \newdwfnamecommands{DWOPdiv}{DW\_OP\_div}
 \newdwfnamecommands{DWOPdrop}{DW\_OP\_drop}
 \newdwfnamecommands{DWOPderefsize}{DW\_OP\_deref\_size}
 \newdwfnamecommands{DWOPdiv}{DW\_OP\_div}
 \newdwfnamecommands{DWOPdrop}{DW\_OP\_drop}
        \newcommand{\DWOPregfive}{\hyperlink{chap:DWOPregn}{DW\_OP\_reg5}}
        \newcommand{\DWOPregten}{\hyperlink{chap:DWOPregn}{DW\_OP\_reg10}}
 \newdwfnamecommands{DWOPregthirtyone}{DW\_OP\_reg31}
        \newcommand{\DWOPregfive}{\hyperlink{chap:DWOPregn}{DW\_OP\_reg5}}
        \newcommand{\DWOPregten}{\hyperlink{chap:DWOPregn}{DW\_OP\_reg10}}
 \newdwfnamecommands{DWOPregthirtyone}{DW\_OP\_reg31}
+\newdwfnamecommands{DWOPregvaltype}{DW\_OP\_regval\_type}
 \newdwfnamecommands{DWOPregx}{DW\_OP\_regx}
 \newdwfnamecommands{DWOPregx}{DW\_OP\_regx}
+\newdwfnamecommands{DWOPreinterpret}{DW\_OP\_reinterpret}
 \newdwfnamecommands{DWOProt}{DW\_OP\_rot}
 \newdwfnamecommands{DWOPshl}{DW\_OP\_shl}
 \newdwfnamecommands{DWOPshr}{DW\_OP\_shr}
 \newdwfnamecommands{DWOProt}{DW\_OP\_rot}
 \newdwfnamecommands{DWOPshl}{DW\_OP\_shl}
 \newdwfnamecommands{DWOPshr}{DW\_OP\_shr}
 \newdwfnamecommands{DWOPstackvalue}{DW\_OP\_stack\_value}
 \newdwfnamecommands{DWOPswap}{DW\_OP\_swap}
 \newdwfnamecommands{DWOPxderef}{DW\_OP\_xderef}
 \newdwfnamecommands{DWOPstackvalue}{DW\_OP\_stack\_value}
 \newdwfnamecommands{DWOPswap}{DW\_OP\_swap}
 \newdwfnamecommands{DWOPxderef}{DW\_OP\_xderef}
+\newdwfnamecommands{DWOPxdereftype}{DW\_OP\_xderef\_type}
 \newdwfnamecommands{DWOPxderefsize}{DW\_OP\_xderef\_size}
 \newdwfnamecommands{DWOPxor}{DW\_OP\_xor}
 %
 \newdwfnamecommands{DWOPxderefsize}{DW\_OP\_xderef\_size}
 \newdwfnamecommands{DWOPxor}{DW\_OP\_xor}
 %
index ec15850..ca2c072 100644 (file)
@@ -832,6 +832,86 @@ Figure~\refersec{fig:assumedrankdwarfparser}.
 \end{figure}
 
 
 \end{figure}
 
 
+\clearpage
+\subsection{Fortran Dynamic Type Example}
+\label{app:fortrandynamictypeexample}
+Consider the \addtoindex{Fortran 90} example of dynamic properties in 
+Figure \refersec{fig:fortrandynamictypeexamplesource}.
+This can be represented in DWARF as illustrated in 
+Figure \refersec{fig:fortrandynamictypeexampledwarfdescription}.
+Note that unnamed dynamic types are used to avoid replicating
+the full description of the underlying type \texttt{dt} that is shared by
+several variables.
+
+\begin{figure}[h]
+\begin{lstlisting}
+           program sample
+     
+        type :: dt (l)
+            integer, len :: l
+            integer :: arr(l)
+        end type
+
+        integer :: n = 4
+        contains
+
+        subroutine s()
+            type (dt(n))               :: t1
+            type (dt(n)), pointer      :: t2
+            type (dt(n)), allocatable  :: t3, t4
+        end subroutine
+     
+        end sample
+\end{lstlisting}
+\caption{Fortran dynamic type example: source}
+\label{fig:fortrandynamictypeexamplesource}
+\end{figure}
+
+\begin{figure}[h]
+\begin{dwflisting}
+\begin{alltt}
+11$:    \DWTAGstructuretype
+            \DWATname("dt")
+            \DWTAGmember
+                ...
+                       ...
+
+13$:    \DWTAGdynamictype             ! plain version
+            \DWATdatalocation (dwarf expression to locate raw data)
+            \DWATtype (11$)
+
+14$:    \DWTAGdynamictype             ! 'pointer' version
+            \DWATdatalocation (dwarf expression to locate raw data)
+            \DWATassociated (dwarf expression to test if associated)
+            \DWATtype (11$)
+
+15$:    \DWTAGdynamictype             ! 'allocatable' version
+            \DWATdatalocation (dwarf expression to locate raw data)
+            \DWATallocated (dwarf expression to test is allocated)
+            \DWATtype (11$)
+
+16$:    \DWTAGvariable
+            \DWATname ("t1")
+            \DWATtype (13$)
+            \DWATlocation (dwarf expression to locate descriptor)
+17$:    \DWTAGvariable
+            \DWATname ("t2")
+            \DWATtype (14$)
+            \DWATlocation (dwarf expression to locate descriptor)
+18$:    \DWTAGvariable
+            \DWATname ("t3")
+            \DWATtype (15$)
+            \DWATlocation (dwarf expression to locate descriptor)
+19$:    \DWTAGvariable
+            \DWATname ("t4")
+            \DWATtype (15$)
+            \DWATlocation (dwarf expression to locate descriptor)
+\end{alltt}
+\end{dwflisting}
+\caption{Fortran dynamic type example: DWARF description}
+\label{fig:fortrandynamictypeexampledwarfdescription}
+\end{figure}
+
 
 \clearpage
 \subsection{Ada Example}
 
 \clearpage
 \subsection{Ada Example}
@@ -1078,85 +1158,7 @@ Figure~\ref{fig:packedrecordexampledwarfdescription}: Packed record example: DWA
 \end{center}
 \end{figure}
 
 \end{center}
 \end{figure}
 
-\clearpage
-\subsection{Fortran Dynamic Type Example}
-\label{app:fortrandynamictypeexample}
-Consider the \addtoindex{Fortran 90} example of dynamic properties in 
-Figure \refersec{fig:fortrandynamictypeexamplesource}.
-This can be represented in DWARF as illustrated in 
-Figure \refersec{fig:fortrandynamictypeexampledwarfdescription}.
-Note that unnamed dynamic types are used to avoid replicating
-the full description of the underlying type \texttt{dt} that is shared by
-several variables.
-
-\begin{figure}[h]
-\begin{lstlisting}
-           program sample
-     
-        type :: dt (l)
-            integer, len :: l
-            integer :: arr(l)
-        end type
-
-        integer :: n = 4
-        contains
-
-        subroutine s()
-            type (dt(n))               :: t1
-            type (dt(n)), pointer      :: t2
-            type (dt(n)), allocatable  :: t3, t4
-        end subroutine
-     
-        end sample
-\end{lstlisting}
-\caption{Fortran dynamic type example: source}
-\label{fig:fortrandynamictypeexamplesource}
-\end{figure}
-
-\begin{figure}[h]
-\begin{dwflisting}
-\begin{alltt}
-11$:    \DWTAGstructuretype
-            \DWATname("dt")
-            \DWTAGmember
-                ...
-                       ...
-
-13$:    \DWTAGdynamictype             ! plain version
-            \DWATdatalocation (dwarf expression to locate raw data)
-            \DWATtype (11$)
-
-14$:    \DWTAGdynamictype             ! 'pointer' version
-            \DWATdatalocation (dwarf expression to locate raw data)
-            \DWATassociated (dwarf expression to test if associated)
-            \DWATtype (11$)
-
-15$:    \DWTAGdynamictype             ! 'allocatable' version
-            \DWATdatalocation (dwarf expression to locate raw data)
-            \DWATallocated (dwarf expression to test is allocated)
-            \DWATtype (11$)
-
-16$:    \DWTAGvariable
-            \DWATname ("t1")
-            \DWATtype (13$)
-            \DWATlocation (dwarf expression to locate descriptor)
-17$:    \DWTAGvariable
-            \DWATname ("t2")
-            \DWATtype (14$)
-            \DWATlocation (dwarf expression to locate descriptor)
-18$:    \DWTAGvariable
-            \DWATname ("t3")
-            \DWATtype (15$)
-            \DWATlocation (dwarf expression to locate descriptor)
-19$:    \DWTAGvariable
-            \DWATname ("t4")
-            \DWATtype (15$)
-            \DWATlocation (dwarf expression to locate descriptor)
-\end{alltt}
-\end{dwflisting}
-\caption{Fortran dynamic type example: DWARF description}
-\label{fig:fortrandynamictypeexampledwarfdescription}
-\end{figure}
+%\clearpage
 
 \clearpage
 \section{Namespace Example}
 
 \clearpage
 \section{Namespace Example}
index 1c4fa27..3438da5 100644 (file)
@@ -760,17 +760,41 @@ Section \refersec{chap:locationdescriptions}.
 \subsection{General Operations}
 \label{chap:generaloperations}
 Each general operation represents a postfix operation on
 \subsection{General Operations}
 \label{chap:generaloperations}
 Each general operation represents a postfix operation on
-a simple stack machine. Each element of the stack is the
-\addtoindex{size of an address} on the target machine. 
-The value on the
-top of the stack after \doublequote{executing} the 
+a simple stack machine. 
+Each element of the stack has a type and a value, and can represent
+a value of any supported base type of the target machine.  Instead of
+a base type, elements can have a special address type, 
+which is an integral type that has the 
+\addtoindex{size of an address} on the target machine and 
+unspecified signedness.The value on the top of the stack after 
+\doublequote{executing} the 
 \addtoindex{DWARF expression}
 is 
 \addtoindex{DWARF expression}
 is 
-\addtoindexx{DWARF expression|see{location description}}
+\addtoindexx{DWARF expression|see{\textit{also} location description}}
 taken to be the result (the address of the object, the
 value of the array bound, the length of a dynamic string,
 the desired value itself, and so on).
 
 taken to be the result (the address of the object, the
 value of the array bound, the length of a dynamic string,
 the desired value itself, and so on).
 
+\needlines{4}
+\textit{While the abstract definition of the stack calls for variable-size entries
+able to hold any supported base type, in practice it is expected that each
+element of the stack can be represented as a fixed-size element large enough
+to hold a value of any type supported by the DWARF consumer for that target,
+plus a small identifier sufficient to encode the type of that element.
+Support for base types other than what is required to do address arithmetic
+is intended only for debugging of optimized code, and the completeness of the
+DWARF consumer's support for the full set of base types is a
+quality-of-implementation issue. If a consumer encounters a DWARF expression
+that uses a type it does not support, it should ignore the entire expression
+and report its inability to provide the requested information.}
+
+\textit{It should also be noted that floating-point arithmetic is highly dependent
+on the computational environment. It is not the intention of this expression
+evaluation facility to produce identical results to those produced by the
+program being debugged while executing on the target machine. Floating-point
+computations in this stack machine will be done with precision control and
+rounding modes as defined by the implementation.}
+
 \needlines{4}
 \subsubsection{Literal Encodings}
 \label{chap:literalencodings}
 \needlines{4}
 \subsubsection{Literal Encodings}
 \label{chap:literalencodings}
@@ -779,9 +803,10 @@ The
 following operations all push a value onto the DWARF
 stack. 
 \addtoindexx{DWARF expression!stack operations}
 following operations all push a value onto the DWARF
 stack. 
 \addtoindexx{DWARF expression!stack operations}
-If the value of a constant in one of these operations
+Operations other than \DWOPconsttype{} push a value with the special 
+address type, and if the value of a constant in one of these operations
 is larger than can be stored in a single stack element, the
 is larger than can be stored in a single stack element, the
-value is truncated to the element size and the low\dash order bits
+value is truncated to the element size and the low-order bits
 are pushed on the stack.
 \begin{enumerate}[1. ]
 \itembfnl{\DWOPlitzeroTARG, \DWOPlitoneTARG, \dots, \DWOPlitthirtyoneTARG}
 are pushed on the stack.
 \begin{enumerate}[1. ]
 \itembfnl{\DWOPlitzeroTARG, \DWOPlitoneTARG, \dots, \DWOPlitthirtyoneTARG}
@@ -834,18 +859,39 @@ require link-time relocation but should not be
 interpreted by the consumer as a relocatable address
 (for example, offsets to thread-local storage).}
 
 interpreted by the consumer as a relocatable address
 (for example, offsets to thread-local storage).}
 
-\end{enumerate}
+\itembfnl{\DWOPconsttypeTARG}
+The \DWOPconsttypeNAME{} operation takes three operands. The first operand is an
+unsigned LEB128 integer that represents the offset of a debugging
+information entry in the current compilation unit, which must be a
+\DWTAGbasetype{} entry that provides the type of the constant provided. The
+second operand is 1-byte unsigned integer that represents the size \texttt{n} of the
+constant, which may not be larger than the size of the largest supported
+base type of the target machine. The third operand is a block of \texttt{n} bytes to
+be interpreted as a value of the referenced type.
+
+\textit{While the size of the constant could be inferred from the base type
+definition, it is encoded explicitly into the expression so that the
+expression can be parsed easily without reference to the \dotdebuginfo{}
+section.}
 
 
+\end{enumerate}
 
 
-\subsubsection{Register Based Addressing}
-\label{chap:registerbasedaddressing}
-The following operations push a value onto the stack that is
+\needlines{10}
+\subsubsection{Register Values}
+\label{chap:registervalues}
+The following operations push a value onto the stack that is either the
+contents of a register or the result of adding the contents of a register
+to a given signed offset. 
 \addtoindexx{DWARF expression!register based addressing}
 \addtoindexx{DWARF expression!register based addressing}
-the result of adding the contents of a register to a given
-signed offset.
+\DWOPregvaltype{} pushes the contents
+of the register together with the given base type, while the other operations
+push the result of adding the contents of a register to a given
+signed offset together with the special address type.
+
+\needlines{4}
 \begin{enumerate}[1. ]
 \itembfnl{\DWOPfbregTARG}
 \begin{enumerate}[1. ]
 \itembfnl{\DWOPfbregTARG}
-The \DWOPfbregTARG{} operation provides a 
+The \DWOPfbregNAME{} operation provides a 
 signed LEB128\addtoindexx{LEB128!signed} offset
 from the address specified by the location description in the
 \DWATframebase{} attribute of the current function. (This
 signed LEB128\addtoindexx{LEB128!signed} offset
 from the address specified by the location description in the
 \DWATframebase{} attribute of the current function. (This
@@ -855,16 +901,26 @@ location list that adjusts the offset according to changes
 in the stack pointer as the PC changes.)
 
 \itembfnl{\DWOPbregzeroTARG, \DWOPbregoneTARG, \dots, \DWOPbregthirtyoneTARG}
 in the stack pointer as the PC changes.)
 
 \itembfnl{\DWOPbregzeroTARG, \DWOPbregoneTARG, \dots, \DWOPbregthirtyoneTARG}
-The single operand of the \DWOPbregnTARG{} 
+The single operand of the \DWOPbregnNAME{} 
 operations provides
 a signed LEB128\addtoindexx{LEB128!signed} offset from
 the specified register.
 
 operations provides
 a signed LEB128\addtoindexx{LEB128!signed} offset from
 the specified register.
 
-\itembfnl{\DWOPbregxTARG{} }
+\itembfnl{\DWOPbregxTARG}
 The \DWOPbregxNAME{} operation has two operands: a register
 which is specified by an unsigned LEB128\addtoindexx{LEB128!unsigned}
 number, followed by a signed LEB128\addtoindexx{LEB128!signed} offset.
 
 The \DWOPbregxNAME{} operation has two operands: a register
 which is specified by an unsigned LEB128\addtoindexx{LEB128!unsigned}
 number, followed by a signed LEB128\addtoindexx{LEB128!signed} offset.
 
+\itembfnl{\DWOPregvaltypeTARG}
+The \DWOPregvaltypeNAME{} operation takes two parameters. The first parameter is
+an unsigned LEB128\addtoindexx{LEB128!unsigned} number, 
+which identifies a register whose contents is to
+be pushed onto the stack. The second parameter is an 
+unsigned LEB128\addtoindexx{LEB128!unsigned} number
+that represents the offset of a debugging information entry in the current
+compilation unit, which must be a \DWTAGbasetype{} entry that provides the
+type of the value contained in the specified register.
+
 \end{enumerate}
 
 
 \end{enumerate}
 
 
@@ -875,51 +931,72 @@ The following
 operations manipulate the DWARF stack. Operations
 that index the stack assume that the top of the stack (most
 recently added entry) has index 0.
 operations manipulate the DWARF stack. Operations
 that index the stack assume that the top of the stack (most
 recently added entry) has index 0.
+
+The \DWOPdup{}, \DWOPdrop{}, \DWOPpick{}, \DWOPover{}, \DWOPswap{}
+and \DWOProt{} operations manipulate the elements of the stack as pairs
+consisting of the value together with its type identifier. 
+The \DWOPderef{}, \DWOPderefsize{}, \DWOPxderef{}, \DWOPxderefsize{} 
+and \DWOPformtlsaddress{}
+operations require the popped values to have an integral type, either the
+special address type or some other integral base type, and push a 
+value with the special address type.  
+\DWOPdereftype{} and \DWOPxdereftype{} operations have the
+same requirement on the popped values, but push a value together 
+with the same type as the popped values.
+All other operations push a value together with the special address type.
+
 \begin{enumerate}[1. ]
 \itembfnl{\DWOPdupTARG}
 \begin{enumerate}[1. ]
 \itembfnl{\DWOPdupTARG}
-The \DWOPdupTARG{} operation duplicates the value at the top of the stack.
+The \DWOPdupNAME{} operation duplicates the value (including its 
+type identifier) at the top of the stack.
 
 \itembfnl{\DWOPdropTARG}
 
 \itembfnl{\DWOPdropTARG}
-The \DWOPdropTARG{} operation pops the value at the top of the stack.
+The \DWOPdropNAME{} operation pops the value (including its type 
+identifier) at the top of the stack.
 
 \itembfnl{\DWOPpickTARG}
 
 \itembfnl{\DWOPpickTARG}
-The single operand of the \DWOPpickTARG{} operation provides a
-1\dash byte index. A copy of the stack entry with the specified
+The single operand of the \DWOPpickNAME{} operation provides a
+1\dash byte index. A copy of the stack entry (including its 
+type identifier) with the specified
 index (0 through 255, inclusive) is pushed onto the stack.
 
 \itembfnl{\DWOPoverTARG}
 index (0 through 255, inclusive) is pushed onto the stack.
 
 \itembfnl{\DWOPoverTARG}
-The \DWOPoverTARG{} operation duplicates the entry currently second
+The \DWOPoverNAME{} operation duplicates the entry currently second
 in the stack at the top of the stack. 
 in the stack at the top of the stack. 
-This is equivalent to
-\DWOPpick{} operation, with index 1.  
+This is equivalent to a
+\DWOPpick{} operation, with index 1.  
 
 \itembfnl{\DWOPswapTARG}
 
 \itembfnl{\DWOPswapTARG}
-The \DWOPswapTARG{} operation swaps the top two stack entries. 
-The entry at the top of the
-stack becomes the second stack entry, 
-and the second entry becomes the top of the stack.
+The \DWOPswapNAME{} operation swaps the top two stack entries. 
+The entry at the top of the stack (including its type identifier)
+becomes the second stack entry, and the second entry (including 
+its type identifier) becomes the top of the stack.
 
 \itembfnl{\DWOProtTARG}
 
 \itembfnl{\DWOProtTARG}
-The \DWOProtTARG{} operation rotates the first three stack
-entries. The entry at the top of the stack becomes the third
-stack entry, the second entry becomes the top of the stack,
-and the third entry becomes the second entry.
+The \DWOProtNAME{} operation rotates the first three stack
+entries. The entry at the top of the stack (including its 
+type identifier) becomes the third stack entry, the second 
+entry (including its type identifier) becomes the top of 
+the stack, and the third entry (including its type identifier)
+becomes the second entry.
 
 \itembfnl{\DWOPderefTARG}
 
 \itembfnl{\DWOPderefTARG}
-The \DWOPderefTARG{} 
-operation  pops the top stack entry and 
-treats it as an address. The value
-retrieved from that address is pushed
+The \DWOPderefNAME{} operation pops the top stack entry and 
+treats it as an address. The popped value must have an integral type.
+The value retrieved from that address is pushed, together with the
+special address type identifier
 The size of the data retrieved from the 
 \addtoindexi{dereferenced}{address!dereference operator}
 address is the \addtoindex{size of an address} on the target machine.
 
 \needlines{4}
 \itembfnl{\DWOPderefsizeTARG}
 The size of the data retrieved from the 
 \addtoindexi{dereferenced}{address!dereference operator}
 address is the \addtoindex{size of an address} on the target machine.
 
 \needlines{4}
 \itembfnl{\DWOPderefsizeTARG}
-The \DWOPderefsizeTARG{} operation behaves like the 
+The \DWOPderefsizeNAME{} operation behaves like the 
 \DWOPderef{}
 operation: it pops the top stack entry and treats it as an
 \DWOPderef{}
 operation: it pops the top stack entry and treats it as an
-address. The value retrieved from that address is pushed. In
+address. The popped value must have an integral type.
+The value retrieved from that address is pushed, together with the
+special address type identifier. In
 the \DWOPderefsizeNAME{} operation, however, the size in bytes
 of the data retrieved from the dereferenced address is
 specified by the single operand. This operand is a 1\dash byte
 the \DWOPderefsizeNAME{} operation, however, the size in bytes
 of the data retrieved from the dereferenced address is
 specified by the single operand. This operand is a 1\dash byte
@@ -928,29 +1005,48 @@ than the \addtoindex{size of an address} on the target machine. The data
 retrieved is zero extended to the size of an address on the
 target machine before being pushed onto the expression stack.
 
 retrieved is zero extended to the size of an address on the
 target machine before being pushed onto the expression stack.
 
+\itembfnl{\DWOPxdereftypeTARG}
+The \DWOPdereftypeNAME{} operation behaves like the \DWOPderefsize{} operation:
+it pops the top stack entry and treats it as an address. 
+The popped value must have an integral type.
+The value retrieved from that address is pushed together with a type identifier. 
+In the \DWOPdereftypeNAME{} operation, the size in
+bytes of the data retrieved from the dereferenced address is specified by
+the first operand. This operand is a 1-byte unsigned integral constant whose
+value may not be larger than the size of the largest supported base type on
+the target machine. The second operand is an unsigned LEB128 integer that
+represents the offset of a debugging information entry in the current
+compilation unit, which must be a \DWTAGbasetype{} entry that provides the
+type of the data pushed.
+
 \needlines{7}
 \itembfnl{\DWOPxderefTARG}
 \needlines{7}
 \itembfnl{\DWOPxderefTARG}
-The \DWOPxderefTARG{} operation provides an extended dereference
+The \DWOPxderefNAME{} operation provides an extended dereference
 mechanism. The entry at the top of the stack is treated as an
 address. The second stack entry is treated as an \doublequote{address
 space identifier} for those architectures that support
 \addtoindexi{multiple}{address space!multiple}
 mechanism. The entry at the top of the stack is treated as an
 address. The second stack entry is treated as an \doublequote{address
 space identifier} for those architectures that support
 \addtoindexi{multiple}{address space!multiple}
-address spaces. The top two stack elements are popped,
+address spaces. 
+Both of these entries must have integral type identifiers.
+The top two stack elements are popped,
 and a data item is retrieved through an implementation-defined
 and a data item is retrieved through an implementation-defined
-address calculation and pushed as the new stack top. The size
-of the data retrieved from the 
+address calculation and pushed as the new stack top together with the
+special address type identifier.
+The size of the data retrieved from the 
 \addtoindexi{dereferenced}{address!dereference operator}
 address is the
 \addtoindex{size of an address} on the target machine.
 
 \itembfnl{\DWOPxderefsizeTARG}
 \addtoindexi{dereferenced}{address!dereference operator}
 address is the
 \addtoindex{size of an address} on the target machine.
 
 \itembfnl{\DWOPxderefsizeTARG}
-The \DWOPxderefsizeTARG{} operation behaves like the
+The \DWOPxderefsizeNAME{} operation behaves like the
 \DWOPxderef{} operation. The entry at the top of the stack is
 treated as an address. The second stack entry is treated as
 an \doublequote{address space identifier} for those architectures
 that support 
 \addtoindexi{multiple}{address space!multiple}
 \DWOPxderef{} operation. The entry at the top of the stack is
 treated as an address. The second stack entry is treated as
 an \doublequote{address space identifier} for those architectures
 that support 
 \addtoindexi{multiple}{address space!multiple}
-address spaces. The top two stack
+address spaces. 
+Both of these entries must have integral type identifiers.
+The top two stack
 elements are popped, and a data item is retrieved through an
 implementation\dash defined address calculation and pushed as the
 new stack top. In the \DWOPxderefsizeNAME{} operation, however,
 elements are popped, and a data item is retrieved through an
 implementation\dash defined address calculation and pushed as the
 new stack top. In the \DWOPxderefsizeNAME{} operation, however,
@@ -960,10 +1056,23 @@ address is specified by the single operand. This operand is a
 1\dash byte unsigned integral constant whose value may not be larger
 than the \addtoindex{size of an address} on the target machine. The data
 retrieved is zero extended to the \addtoindex{size of an address} on the
 1\dash byte unsigned integral constant whose value may not be larger
 than the \addtoindex{size of an address} on the target machine. The data
 retrieved is zero extended to the \addtoindex{size of an address} on the
-target machine before being pushed onto the expression stack.
+target machine before being pushed onto the expression stack together
+with the special address type identifier.
+
+\itembfnl{\DWOPxdereftypeTARG}
+The \DWOPxdereftypeNAME{} operation behaves like the \DWOPxderefsize{}
+operation: it pops the top two stack entries, treats them as an address and
+an address space identifier, and pushes the value retrieved. In the
+\DWOPxdereftypeNAME{} operation, the size in bytes of the data retrieved from
+the dereferenced address is specified by the first operand. This operand is
+a 1-byte unsigned integral constant whose value may not be larger than the
+size of the largest supported base type on the target machine. The second
+operand is an unsigned LEB128 integer that represents the offset of a
+debugging information entry in the current compilation unit, which must be a
+\DWTAGbasetype{} entry that provides the type of the data pushed.
 
 \itembfnl{\DWOPpushobjectaddressTARG}
 
 \itembfnl{\DWOPpushobjectaddressTARG}
-The \DWOPpushobjectaddressTARG{}
+The \DWOPpushobjectaddressNAME{}
 operation pushes the address
 of the object currently being evaluated as part of evaluation
 of a user presented expression. This object may correspond
 operation pushes the address
 of the object currently being evaluated as part of evaluation
 of a user presented expression. This object may correspond
@@ -984,12 +1093,13 @@ Appendix \refersec{app:aggregateexamples}.}
 
 \needlines{4}
 \itembfnl{\DWOPformtlsaddressTARG}
 
 \needlines{4}
 \itembfnl{\DWOPformtlsaddressTARG}
-The \DWOPformtlsaddressTARG{} 
-operation pops a value from the stack, translates this
+The \DWOPformtlsaddressNAME{} 
+operation pops a value from the stack, which must have an 
+integral type identifier, translates this
 value into an address in the 
 \addtoindexx{thread-local storage}
 thread\dash local storage for a thread, and pushes the address 
 value into an address in the 
 \addtoindexx{thread-local storage}
 thread\dash local storage for a thread, and pushes the address 
-onto the stack. 
+onto the stack togethe with the special address type identifier
 The meaning of the value on the top of the stack prior to this 
 operation is defined by the run-time environment.  If the run-time 
 environment supports multiple thread\dash local storage 
 The meaning of the value on the top of the stack prior to this 
 operation is defined by the run-time environment.  If the run-time 
 environment supports multiple thread\dash local storage 
@@ -1021,7 +1131,7 @@ to perform the computation based on the run-time environment.}
 
 \needlines{4}
 \itembfnl{\DWOPcallframecfaTARG}
 
 \needlines{4}
 \itembfnl{\DWOPcallframecfaTARG}
-The \DWOPcallframecfaTARG{} 
+The \DWOPcallframecfaNAME{} 
 operation pushes the value of the
 CFA, obtained from the Call Frame Information 
 (see Section \refersec{chap:callframeinformation}).
 operation pushes the value of the
 CFA, obtained from the Call Frame Information 
 (see Section \refersec{chap:callframeinformation}).
@@ -1036,18 +1146,26 @@ is present, then it already encodes such changes, and it is
 space efficient to reference that.}
 \end{enumerate}
 
 space efficient to reference that.}
 \end{enumerate}
 
-\subsubsection{Arithmetic and Logical Operations}
-The 
+\subsubsection{Arithmetic and Logical Operations} 
 \addtoindexx{DWARF expression!arithmetic operations}
 \addtoindexx{DWARF expression!arithmetic operations}
-following 
 \addtoindexx{DWARF expression!logical operations}
 \addtoindexx{DWARF expression!logical operations}
-provide arithmetic and logical operations. Except
-as otherwise specified, the arithmetic operations perform
-addressing arithmetic, that is, unsigned arithmetic that is
-performed modulo one plus the largest representable address
-(for example, 0x100000000 when the 
-\addtoindex{size of an address} is 32 bits). 
-Such operations do not cause an exception on overflow.
+The following provide arithmetic and logical operations.  If an operation
+pops two values from the stack, both values must have the same type,
+either the same base type or both the special address type.
+The result of the operation which is pushed back has the same type
+as the type of the operands.  
+
+If the type of the operands is the special
+address type, except as otherwise specified, the arithmetic operations
+perform addressing arithmetic, that is, unsigned arithmetic that is performed
+modulo one plus the largest representable address (for example, 0x100000000
+when the \addtoindex{size of an address} is 32 bits). 
+
+Operations other than \DWOPabs{},
+\DWOPdiv{}, \DWOPminus{}, \DWOPmul{}, \DWOPneg{} and \DWOPplus{} require integral
+types of the operand (either integral base type or the special address
+type).  Operations do not cause an exception on overflow.
+
 
 \needlines{4}
 \begin{enumerate}[1. ]
 
 \needlines{4}
 \begin{enumerate}[1. ]
@@ -1142,7 +1260,8 @@ following operations provide simple control of the flow of a DWARF expression.
 \itembfnl{\DWOPleTARG, \DWOPgeTARG, \DWOPeqTARG, \DWOPltTARG, \DWOPgtTARG, \DWOPneTARG}
 The six relational operators each:
 \begin{itemize}
 \itembfnl{\DWOPleTARG, \DWOPgeTARG, \DWOPeqTARG, \DWOPltTARG, \DWOPgtTARG, \DWOPneTARG}
 The six relational operators each:
 \begin{itemize}
-\item pop the top two stack values,
+\item pop the top two stack values, which should both have the same type,
+either the same base type or both the special address type, 
 
 \item compare the operands:
 \linebreak
 
 \item compare the operands:
 \linebreak
@@ -1151,23 +1270,25 @@ The six relational operators each:
 \item push the constant value 1 onto the stack 
 if the result of the operation is true or the
 constant value 0 if the result of the operation is false.
 \item push the constant value 1 onto the stack 
 if the result of the operation is true or the
 constant value 0 if the result of the operation is false.
+The pushed value has the special address type.
 \end{itemize}
 
 \end{itemize}
 
-Comparisons are performed as signed operations. The six
-operators are \DWOPleNAME{} (less than or equal to), \DWOPgeNAME{}
+If the operands have the special address type, the comparisons  
+are performed as signed operations.
+The six operators are \DWOPleNAME{} (less than or equal to), \DWOPgeNAME{}
 (greater than or equal to), \DWOPeqNAME{} (equal to), \DWOPltNAME{} (less
 than), \DWOPgtNAME{} (greater than) and \DWOPneNAME{} (not equal to).
 
 \needlines{6}
 \itembfnl{\DWOPskipTARG}
 (greater than or equal to), \DWOPeqNAME{} (equal to), \DWOPltNAME{} (less
 than), \DWOPgtNAME{} (greater than) and \DWOPneNAME{} (not equal to).
 
 \needlines{6}
 \itembfnl{\DWOPskipTARG}
-\DWOPskipTARG{} is an unconditional branch. Its single operand
+\DWOPskipNAME{} is an unconditional branch. Its single operand
 is a 2\dash byte signed integer constant. The 2\dash byte constant is
 the number of bytes of the DWARF expression to skip forward
 or backward from the current operation, beginning after the
 2\dash byte constant.
 
 \itembfnl{\DWOPbraTARG}
 is a 2\dash byte signed integer constant. The 2\dash byte constant is
 the number of bytes of the DWARF expression to skip forward
 or backward from the current operation, beginning after the
 2\dash byte constant.
 
 \itembfnl{\DWOPbraTARG}
-\DWOPbraTARG{} is a conditional branch. Its single operand is a
+\DWOPbraNAME{} is a conditional branch. Its single operand is a
 2\dash byte signed integer constant.  This operation pops the
 top of stack. If the value popped is not the constant 0,
 the 2\dash byte constant operand is the number of bytes of the
 2\dash byte signed integer constant.  This operation pops the
 top of stack. If the value popped is not the constant 0,
 the 2\dash byte constant operand is the number of bytes of the
@@ -1225,8 +1346,42 @@ the stack by the called expression may be used as return values
 by prior agreement between the calling and called expressions.
 \end{enumerate}
 
 by prior agreement between the calling and called expressions.
 \end{enumerate}
 
+\subsubsection{Type Conversions}
+\label{chap:typeconversions}
+The following operations provides for explicit type conversion.
+
+\begin{enumerate}[1. ]
+\itembfnl{\DWOPconvertTARG}
+The \DWOPconvertNAME{} operation pops the top stack entry, converts it to a
+different type, then pushes the result. It takes one operand, which is an
+unsigned LEB128 integer that represents the offset of a debugging
+information entry in the current compilation unit, or value 0 which
+represents the special address type. If the operand is non-zero, the
+referenced entry must be a \DWTAGbasetype{} entry that provides the type
+to which the value is converted.
+
+\itembfnl{\DWOPreinterpretTARG}
+The \DWOPreinterpretNAME{} operation pops the top stack entry, reinterprets
+the bits in its value as a value of a different type, then pushes the
+result. It takes one operand, which is an unsigned LEB128 integer that
+represents the offset of a debugging information entry in the current
+compilation unit, or value 0 which represents the special address type.
+If the operand is non-zero, the referenced entry must be a
+\DWTAGbasetype{} entry that provides the type to which the value is converted.
+The type of the operand and result type should have the same size in bits.
+
+\textit{The semantics of the reinterpretation of a value is as if in 
+\addtoindex{C} or \addtoindex{C++}
+there are two variables, one with the type of the operand, into which
+the popped value is stored, then copied using \texttt{memcpy} into the other variable
+with the type of the result and the pushed result value is the value of the
+other variable after \texttt{memcpy}.}
+
+\end{enumerate}
+
 \needlines{7}
 \subsubsection{Special Operations}
 \needlines{7}
 \subsubsection{Special Operations}
+\label{chap:specialoperations}
 There 
 \addtoindexx{DWARF expression!special operations}
 are these special operations currently defined:
 There 
 \addtoindexx{DWARF expression!special operations}
 are these special operations currently defined:
@@ -1282,36 +1437,36 @@ examples illustrate their behavior graphically.}
 \hline
 \endhead
 \endfoot
 \hline
 \endhead
 \endfoot
-0& 17& \DWOPdup{} &0 &17 \\
-1&   29& &  1 & 17 \\
-2& 1000 & & 2 & 29\\
+0& 17& \DWOPdup{} &0 &17 \\*
+1&   29& &  1 & 17 \\*
+2& 1000 & & 2 & 29\\*
 & & &         3&1000\\
 
 & & & & \\
 & & &         3&1000\\
 
 & & & & \\
-0 & 17 & \DWOPdrop{} & 0 & 29 \\
-1 &29  &            & 1 & 1000 \\
+0 & 17 & \DWOPdrop{} & 0 & 29 \\*
+1 &29  &            & 1 & 1000 \\*
 2 &1000& & &          \\
 
 & & & & \\
 2 &1000& & &          \\
 
 & & & & \\
-0 & 17 & \DWOPpick, 2 & 0 & 1000 \\
-1 & 29 & & 1&17 \\
-2 &1000& &2&29 \\
+0 & 17 & \DWOPpick, 2 & 0 & 1000 \\*
+1 & 29 & & 1&17 \\*
+2 &1000& &2&29 \\*
   &    & &3&1000 \\
 
 & & & & \\
   &    & &3&1000 \\
 
 & & & & \\
-0&17& \DWOPover&0&29 \\
-1&29& &  1&17 \\
-2&1000 & & 2&29\\
+0&17& \DWOPover&0&29 \\*
+1&29& &  1&17 \\*
+2&1000 & & 2&29\\*
  &     & & 3&1000 \\
 
 & & & & \\
  &     & & 3&1000 \\
 
 & & & & \\
-0&17& \DWOPswap{} &0&29 \\
-1&29& &  1&17 \\
+0&17& \DWOPswap{} &0&29 \\*
+1&29& &  1&17 \\*
 2&1000 & & 2&1000 \\
 
 & & & & \\
 2&1000 & & 2&1000 \\
 
 & & & & \\
-0&17&\DWOProt{} & 0 &29 \\
-1&29 & & 1 & 1000 \\
+0&17&\DWOProt{} & 0 &29 \\*
+1&29 & & 1 & 1000 \\*
 2& 1000 & &  2 & 17 \\
 \end{longtable}
 
 2& 1000 & &  2 & 17 \\
 \end{longtable}
 
@@ -1441,7 +1596,7 @@ located in a given register.
 \textit{Register location descriptions describe an object
 (or a piece of an object) that resides in a register, while
 the opcodes listed in 
 \textit{Register location descriptions describe an object
 (or a piece of an object) that resides in a register, while
 the opcodes listed in 
-Section \refersec{chap:registerbasedaddressing}
+Section \refersec{chap:registervalues}
 are used to describe an object (or a piece of
 an object) that is located in memory at an address that is
 contained in a register (possibly offset by some constant). A
 are used to describe an object (or a piece of
 an object) that is located in memory at an address that is
 contained in a register (possibly offset by some constant). A
@@ -1477,7 +1632,7 @@ operand that encodes the name of a register.
 fetch the contents of a register, it is necessary to use
 one of the register based addressing operations, such as
 \DWOPbregx{} 
 fetch the contents of a register, it is necessary to use
 one of the register based addressing operations, such as
 \DWOPbregx{} 
-(Section \refersec{chap:registerbasedaddressing})}.
+(Section \refersec{chap:registervalues})}.
 
 \subsubsubsection{Implicit Location Descriptions}
 An \addtoindex{implicit location description}
 
 \subsubsubsection{Implicit Location Descriptions}
 An \addtoindex{implicit location description}
@@ -1823,6 +1978,7 @@ list do not collectively cover the entire range over which the
 object in question is defined, it is assumed that the object is
 not available for the portion of the range that is not covered.
 
 object in question is defined, it is assumed that the object is
 not available for the portion of the range that is not covered.
 
+\needlines{4}
 A default location list entry consists of:
 \addtoindexx{location list!default entry}
 \begin{enumerate}[1. ]
 A default location list entry consists of:
 \addtoindexx{location list!default entry}
 \begin{enumerate}[1. ]
@@ -2052,6 +2208,7 @@ Table \refersec{tab:virtualitycodes}.
 \DWVIRTUALITYpurevirtualTARG{}    \\
 \end{simplenametable}
 
 \DWVIRTUALITYpurevirtualTARG{}    \\
 \end{simplenametable}
 
+\needlines{8}
 \section{Artificial Entries}
 \label{chap:artificialentries}
 \textit{A compiler may wish to generate debugging information entries
 \section{Artificial Entries}
 \label{chap:artificialentries}
 \textit{A compiler may wish to generate debugging information entries
@@ -2144,6 +2301,7 @@ however,
 is common to all encodings, and means that no address class
 has been specified.
 
 is common to all encodings, and means that no address class
 has been specified.
 
+\needlines{4}
 \textit {For example, the Intel386 \texttrademark\  processor might use the following values:}
 
 \begin{table}[here]
 \textit {For example, the Intel386 \texttrademark\  processor might use the following values:}
 
 \begin{table}[here]
@@ -2529,9 +2687,11 @@ first address past the end of the address range.
 The ending address must be greater than or
 equal to the beginning address.
 
 The ending address must be greater than or
 equal to the beginning address.
 
-\textit{A \addtoindex{range list} entry (but not a base address selection or end of list entry) whose beginning and
-ending addresses are equal has no effect because the size of the range covered by such an
-entry is zero.}
+\needlines{4}
+\textit{A \addtoindex{range list} entry (but not a base address 
+selection or end of list entry) whose beginning and
+ending addresses are equal has no effect because the size of the 
+range covered by such an entry is zero.}
 \end{enumerate}
 
 The applicable base address of a \addtoindex{range list} entry
 \end{enumerate}
 
 The applicable base address of a \addtoindex{range list} entry
index dc438ab..44a35eb 100644 (file)
@@ -136,23 +136,43 @@ albeit possibly in a degraded manner.
 The following is a list of the major changes made to the DWARF Debugging Information
 Format since Version 4 was published. The list is not meant to be exhaustive.
 \begin{itemize}
 The following is a list of the major changes made to the DWARF Debugging Information
 Format since Version 4 was published. The list is not meant to be exhaustive.
 \begin{itemize}
-\item TBD...
-\item Added a new attribute, \DWATrank{}, to describe the dimensionality of
+\item OTHERS TBD...
+\item Add a split object file and package representations to allow most 
+DWARF information to be compacted and/or kept separate from an executable 
+or shared image. This includes new sections 
+\dotdebugaddr, \dotdebugstroffsets, \dotdebugabbrevdwo, \dotdebuginfodwo, 
+\dotdebuglinedwo, \dotdebuglocdwo, \dotdebugmacrodwo, \dotdebugstrdwo,
+\dotdebugstroffsetsdwo, \dotdebugcuindex{} and \dotdebugtuindex{} 
+together with new forms of attribute value for referencing these sections.
+This enhances DWARF support for very large programs.
+\item Replace the \dotdebugmacinfo{} macro information representation with
+a much more compact \dotdebugmacro{} representation.
+\item Add a new debugging information entry and related attributes and
+DWARF expression operators for describing call information, 
+including identification of tail calls and tail recursion.
+\item Add a new attribute, \DWATnoreturn{}, to identify a subprogram that 
+does not return to its caller.
+\item Add a new attribute, \DWATrank{}, to describe the dimensionality of
 an array with dynamic rank.
 an array with dynamic rank.
-\item Added a new tag, \DWTAGgenericsubrange{}, to describe the
+\item Add a new tag, \DWTAGgenericsubrange{}, to describe the
 bounds of Fortran assumed-rank arrays.
 bounds of Fortran assumed-rank arrays.
-
+\item Add language codes for C 2011, C++ 2003, C++ 2011, Dylan, Go, Haskell, 
+Julia, Modula 3, Ocaml, Rust, OpenCL and Swift.
 \end{itemize}
 
 DWARF Version 5 is compatible with DWARF Version 4 except as follows:
 \begin{itemize}
 \item A location list entry (see Section \refersec{chap:locationlists}) with 
 \end{itemize}
 
 DWARF Version 5 is compatible with DWARF Version 4 except as follows:
 \begin{itemize}
 \item A location list entry (see Section \refersec{chap:locationlists}) with 
-the address range (0, \doublequote{-1}) is defined as the new default location 
+the address range \mbox{(0, \doublequote{-1})} is defined as the new default location 
 list entry.
 \item In a string type (see Section \refersec{chap:stringtypeentries}), a \DWATbytesize{}
 attribute is defined to always describe the size of the string type. (Previously
 it described the size of the optional string length data field if the \DWATstringlength{}
 attribute was present.)
 list entry.
 \item In a string type (see Section \refersec{chap:stringtypeentries}), a \DWATbytesize{}
 attribute is defined to always describe the size of the string type. (Previously
 it described the size of the optional string length data field if the \DWATstringlength{}
 attribute was present.)
+\item The macro information representation is completely new; however, producers 
+and consumers can optionally continue to support the older representation. While
+the two representations cannot both be used in the same compilation unit, they can
+co-exist in executable or shared images.
 \end{itemize}
 
 \needlines{4}
 \end{itemize}
 
 \needlines{4}
index c7df5be..23842dc 100644 (file)
@@ -1205,25 +1205,25 @@ The bits of the \texttt{flags} field are interpreted as a set
 of flags, some of which may indicate that additional fields follow.
 The following flags, beginning with the least significant bit, are defined:
 \begin{itemize}
 of flags, some of which may indicate that additional fields follow.
 The following flags, beginning with the least significant bit, are defined:
 \begin{itemize}
-\item \addttindex{offset\_size} flag \\
+\item \addttindex{offset\_size\_flag} \\
 If the \texttt{offset\_size} flag is clear, the header is for a 32-bit 
 DWARF format macro section and all offsets are 4 bytes long;
 if it is set, the header is for a 64-bit DWARF format macro section 
 and all offsets are 8 bytes long.
 If the \texttt{offset\_size} flag is clear, the header is for a 32-bit 
 DWARF format macro section and all offsets are 4 bytes long;
 if it is set, the header is for a 64-bit DWARF format macro section 
 and all offsets are 8 bytes long.
-\item \addttindex{debug\_line\_ section\_ offset} flag -- see below
-\item \addttindex{opcode\_operands\_table} flag -- see below
+\item \addttindex{debug\_line\_section\_offset\_flag} -- see below
+\item \addttindex{opcode\_operands\_table\_flag} -- see below
 \end{itemize}
 All other flags are reserved by DWARF.
 
 \item \addttindex{debug\_line\_section\_offset} \\
 \end{itemize}
 All other flags are reserved by DWARF.
 
 \item \addttindex{debug\_line\_section\_offset} \\
-If the \texttt{debug\_line\_ section\_offset} flag is set,
+If the \texttt{debug\_line\_section\_offset\_flag} is set,
 there follows an offset in the \dotdebugline{} section of the
 beginning of the line number information, encoded as 4-byte offset for
 a 32-bit DWARF format macro section and 8-byte offset for a 64-bit DWARF format
 macro section.  
 
 \item \addttindex{opcode\_operands\_table} \\
 there follows an offset in the \dotdebugline{} section of the
 beginning of the line number information, encoded as 4-byte offset for
 a 32-bit DWARF format macro section and 8-byte offset for a 64-bit DWARF format
 macro section.  
 
 \item \addttindex{opcode\_operands\_table} \\
-If the \texttt{opcode\_operands\_table} flag is set, there follows
+If the \texttt{opcode\_operands\_table\_flag} is set, there follows
 an \texttt{opcode\_operands\_table} describing the operands of the macro information entry opcodes.
 The macro information entries defined in this standard may, but need not, be
 described in the table, while other user-defined entry opcodes used in the section
 an \texttt{opcode\_operands\_table} describing the operands of the macro information entry opcodes.
 The macro information entries defined in this standard may, but need not, be
 described in the table, while other user-defined entry opcodes used in the section
@@ -1560,6 +1560,7 @@ Frame Address value; it may be either a register and a signed
 offset that are added together, or a DWARF expression that
 is evaluated.
 
 offset that are added together, or a DWARF expression that
 is evaluated.
 
+\needlines{4}
 The remaining columns are labelled by register number. This
 includes some registers that have special designation on
 some architectures such as the PC and the stack pointer
 The remaining columns are labelled by register number. This
 includes some registers that have special designation on
 some architectures such as the PC and the stack pointer
index 0f47422..6ef456b 100644 (file)
@@ -153,6 +153,7 @@ Language name & Meaning\\ \hline
 \DWLANGCobolseventyfourTARG & ISO COBOL:1974 \addtoindexx{COBOL:1974 (ISO)} \\
 \DWLANGCoboleightyfiveTARG  & ISO COBOL:1985 \addtoindexx{COBOL:1985 (ISO)} \\
 \DWLANGDTARG{}~\dag & D \addtoindexx{D language} \\
 \DWLANGCobolseventyfourTARG & ISO COBOL:1974 \addtoindexx{COBOL:1974 (ISO)} \\
 \DWLANGCoboleightyfiveTARG  & ISO COBOL:1985 \addtoindexx{COBOL:1985 (ISO)} \\
 \DWLANGDTARG{}~\dag & D \addtoindexx{D language} \\
+\DWLANGDylanTARG~\dag & Dylan \addtoindexx{Dylan language} \\
 \DWLANGFortranseventysevenTARG & ISO FORTRAN:1977 \addtoindexx{FORTRAN:1977 (ISO)} \\
 \DWLANGFortranninetyTARG       & ISO Fortran:1990 \addtoindexx{Fortran:1990 (ISO)} \\
 \DWLANGFortranninetyfiveTARG   & ISO Fortran:1995 \addtoindexx{Fortran:1995 (ISO)} \\
 \DWLANGFortranseventysevenTARG & ISO FORTRAN:1977 \addtoindexx{FORTRAN:1977 (ISO)} \\
 \DWLANGFortranninetyTARG       & ISO Fortran:1990 \addtoindexx{Fortran:1990 (ISO)} \\
 \DWLANGFortranninetyfiveTARG   & ISO Fortran:1995 \addtoindexx{Fortran:1995 (ISO)} \\
@@ -1586,6 +1587,7 @@ Each such entry should be a direct
 child of the entry that represents the scope within which
 the inlining occurs.
 
 child of the entry that represents the scope within which
 the inlining occurs.
 
+\needlines{4}
 Each inlined subroutine entry may have either a 
 \DWATlowpc{}
 and \DWAThighpc{} pair 
 Each inlined subroutine entry may have either a 
 \DWATlowpc{}
 and \DWAThighpc{} pair 
@@ -1678,6 +1680,7 @@ in the \addtoindex{nested concrete inline instance} tree
 are not considered to
 be entries in the outer concrete instance tree.
 
 are not considered to
 be entries in the outer concrete instance tree.
 
+\needlines{3}
 \textit{Concrete inlined instance trees are defined so that no entry
 is part of more than one concrete inlined instance tree. This
 simplifies later descriptions.}
 \textit{Concrete inlined instance trees are defined so that no entry
 is part of more than one concrete inlined instance tree. This
 simplifies later descriptions.}
@@ -2001,6 +2004,7 @@ where at least one instruction has the location of the inlined subprogram
 or any of its blocks or inlined subprograms. 
 \end{itemize}
 
 or any of its blocks or inlined subprograms. 
 \end{itemize}
 
+\needlines{4}
 There are also different types of \doublequote{optimized out} calls:
 \begin{itemize}
 \item
 There are also different types of \doublequote{optimized out} calls:
 \begin{itemize}
 \item
@@ -2203,6 +2207,7 @@ There is
 one such debugging information entry for each local declaration
 of an identifier or inner lexical \nolink{block}.
 
 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
 \section{Label Entries}
 \label{chap:labelentries}
 \textit{A label is a way of identifying a source statement. A labeled
index abbbd40..399fa89 100644 (file)
@@ -147,9 +147,9 @@ floating\dash point number \\
 \DWATEsignedfixedTARG{} & signed fixed\dash point scaled integer \\
 \DWATEunsignedfixedTARG& unsigned fixed\dash point scaled integer \\
 \DWATEdecimalfloatTARG{} & decimal floating\dash point number \\ 
 \DWATEsignedfixedTARG{} & signed fixed\dash point scaled integer \\
 \DWATEunsignedfixedTARG& unsigned fixed\dash point scaled integer \\
 \DWATEdecimalfloatTARG{} & decimal floating\dash point number \\ 
-\DWATEUTFTARG{} & \addtoindex{Unicode} character (two-byte UTF-8) \\
-\DWATEASCIITARG{} & \addtoindex{ASCII} character (one-byte) \\
-\DWATEUCSTARG{} & \addtoindex{ISO 10646} character (four-byte) \\
+\DWATEUTFTARG{} & \addtoindex{Unicode} character \\
+\DWATEASCIITARG{} & \addtoindex{ASCII} character \\
+\DWATEUCSTARG{} & \addtoindex{ISO 10646} character \\
 \hline
 \end{tabular}
 \end{table}
 \hline
 \end{tabular}
 \end{table}
@@ -1621,6 +1621,7 @@ has been given to the condition, the condition entry has a
 whose value is a null\dash terminated string
 giving the condition name as it appears in the source program.
 
 whose value is a null\dash terminated string
 giving the condition name as it appears in the source program.
 
+\needlines{4}
 The condition entry's parent entry describes the conditional
 variable; normally this will be a \DWTAGvariable,
 \DWTAGmember{} or 
 The condition entry's parent entry describes the conditional
 variable; normally this will be a \DWTAGvariable,
 \DWTAGmember{} or 
@@ -2243,8 +2244,10 @@ reference to the type of the entities that are dynamically allocated.
        
 A dynamic type entry also has a \DWATdatalocation, and may also
 have \DWATallocated{} and/or \DWATassociated{} attributes as 
        
 A dynamic type entry also has a \DWATdatalocation, and may also
 have \DWATallocated{} and/or \DWATassociated{} attributes as 
-described in Section \referfol{chap:dynamictypeproperties}. The type referenced by the
-\DWATtype{} attribute must not have any of these attributes.
+described in Section \referfol{chap:dynamictypeproperties}. 
+A \DWATdatalocation, \DWATallocated{} or \DWATassociated{} attribute 
+may not occur on a dynamic type entry if the same kind of attribute 
+already occurs on the type referenced by the \DWATtype{} attribute.
 
 \subsection{Dynamic Type Properties}
 \label{chap:dynamictypeproperties}
 
 \subsection{Dynamic Type Properties}
 \label{chap:dynamictypeproperties}