Bring up to date with approved issues as of April 2014.
authorRon Brender <ron.brender@gmail.com>
Tue, 13 May 2014 17:44:14 +0000 (13:44 -0400)
committerRon Brender <ron.brender@gmail.com>
Tue, 13 May 2014 17:44:14 +0000 (13:44 -0400)
Signed-off-by: Ron Brender <ron.brender@gmail.com>
12 files changed:
dwarf5/latexdoc/attributesbytag.tex
dwarf5/latexdoc/changesummary.tex
dwarf5/latexdoc/datarepresentation.tex
dwarf5/latexdoc/debugsectionrelationships.tex
dwarf5/latexdoc/dwarf5.tex
dwarf5/latexdoc/dwarfnamecmds.tex
dwarf5/latexdoc/examples.tex
dwarf5/latexdoc/generaldescription.tex
dwarf5/latexdoc/programscope.tex
dwarf5/latexdoc/sectionversionnumbers.tex
dwarf5/latexdoc/splitobjects.tex
dwarf5/latexdoc/typeentries.tex

index 41136a8..d1a1e8c 100644 (file)
@@ -19,7 +19,8 @@ In the following table,
 \livetarg{chap:DECL}{}
 means include all three of the
 \addtoindex{declaration coordinates} 
 \livetarg{chap:DECL}{}
 means include all three of the
 \addtoindex{declaration coordinates} 
-\addtoindexx{declaration coordinates|see {\DWATdeclfileNAME, \DWATdecllineNAME, \DWATdeclcolumnNAME}}
+%\addtoindexx{declaration coordinates|see 
+%    {DW\_AT\_decl\_file, DW\_AT\_decl\_line, DW\_AT\_decl\_column}}
 \DWATdeclcolumn,
 \DWATdeclfile{} and 
 \DWATdeclline.
 \DWATdeclcolumn,
 \DWATdeclfile{} and 
 \DWATdeclline.
@@ -94,6 +95,30 @@ means include all three of the
 &\DWATsibling{} \\*
 &\DWATsmall{} \\*
 
 &\DWATsibling{} \\*
 &\DWATsmall{} \\*
 
+\hline
+\DWTAGcallsite
+&\DWATcallcolumn        \\*
+&\DWATcallfile          \\*
+&\DWATcallline          \\*
+&\DWATcallorigin        \\
+&\DWATcallpc            \\
+&\DWATcallreturnpc      \\
+&\DWATcalltailcall      \\
+&\DWATcalltarget        \\*
+&\DWATcalltargetclobbered \\*
+&\DWATtype              \\*
+
+\hline
+\DWTAGcallsiteparameter
+&\DWATcalldatalocation  \\*
+&\DWATcalldatavalue     \\*
+&\DWATcallparameter     \\*
+&\DWATcallvalue         \\
+&\DWATlocation          \\
+&\DWATname              \\*
+&\DWATsibling           \\*
+&\DWATtype              \\*
+
 \hline
 \DWTAGcatchblock
 &\livelink{chap:DECL}{DECL} \\*
 \hline
 \DWTAGcatchblock
 &\livelink{chap:DECL}{DECL} \\*
@@ -107,9 +132,9 @@ means include all three of the
 
 \hline
 \DWTAGclasstype
 
 \hline
 \DWTAGclasstype
-&\livelink{chap:DECL}{DECL} \\
-&\DWATabstractorigin{} \\
-&\DWATaccessibility{} \\
+&\livelink{chap:DECL}{DECL} \\*
+&\DWATabstractorigin{} \\*
+&\DWATaccessibility{} \\*
 &\DWATallocated{} \\
 &\DWATassociated{} \\
 &\DWATbitsize{} \\
 &\DWATallocated{} \\
 &\DWATassociated{} \\
 &\DWATbitsize{} \\
@@ -146,9 +171,9 @@ means include all three of the
 
 \hline
 \DWTAGcommoninclusion
 
 \hline
 \DWTAGcommoninclusion
-&\livelink{chap:DECL}{DECL} \\
-&\DWATcommonreference{} \\
-&\DWATdeclaration{} \\
+&\livelink{chap:DECL}{DECL} \\*
+&\DWATcommonreference{} \\*
+&\DWATdeclaration{} \\*
 &\DWATsibling{} \\
 &\DWATvisibility{} \\
 
 &\DWATsibling{} \\
 &\DWATvisibility{} \\
 
@@ -189,9 +214,9 @@ means include all three of the
 
 \hline
 \DWTAGconstant
 
 \hline
 \DWTAGconstant
-&\livelink{chap:DECL}{DECL} \\
-&\DWATaccessibility{} \\
-&\DWATconstvalue{} \\
+&\livelink{chap:DECL}{DECL} \\*
+&\DWATaccessibility{} \\*
+&\DWATconstvalue{} \\*
 &\DWATdeclaration{} \\
 &\DWATdescription{} \\
 &\DWATendianity{} \\
 &\DWATdeclaration{} \\
 &\DWATdescription{} \\
 &\DWATendianity{} \\
@@ -569,9 +594,9 @@ means include all three of the
 
 \hline
 \DWTAGstringtype
 
 \hline
 \DWTAGstringtype
-&\livelink{chap:DECL}{DECL}  \\
-&\DWATabstractorigin{}  \\
-&\DWATaccessibility{}  \\
+&\livelink{chap:DECL}{DECL}  \\*
+&\DWATabstractorigin{}  \\*
+&\DWATaccessibility{}  \\*
 &\DWATallocated{}  \\
 &\DWATassociated{}  \\
 &\DWATbitsize{}  \\
 &\DWATallocated{}  \\
 &\DWATassociated{}  \\
 &\DWATbitsize{}  \\
@@ -602,9 +627,9 @@ means include all three of the
 &\DWATname{}  \\
 &\DWATsibling{}  \\
 &\DWATsignature{}  \\
 &\DWATname{}  \\
 &\DWATsibling{}  \\
 &\DWATsignature{}  \\
-&\DWATspecification{}  \\
-&\DWATstartscope{}  \\
-&\DWATvisibility{}  \\
+&\DWATspecification{}  \\*
+&\DWATstartscope{}  \\*
+&\DWATvisibility{}  \\*
 
 \hline
 \DWTAGsubprogram
 
 \hline
 \DWTAGsubprogram
@@ -642,9 +667,9 @@ means include all three of the
 &\DWATstaticlink{}  \\
 &\DWATtrampoline{}  \\
 &\DWATtype{}  \\
 &\DWATstaticlink{}  \\
 &\DWATtrampoline{}  \\
 &\DWATtype{}  \\
-&\DWATvisibility{}  \\
-&\DWATvirtuality{}  \\
-&\DWATvtableelemlocation{}  \\
+&\DWATvisibility{}  \\*
+&\DWATvirtuality{}  \\*
+&\DWATvtableelemlocation{}  \\*
 
 \hline
 \DWTAGsubrangetype
 
 \hline
 \DWTAGsubrangetype
@@ -711,9 +736,9 @@ means include all three of the
 &\livelink{chap:DECL}{DECL}   \\
 &\DWATdefaultvalue{}   \\
 &\DWATdescription{}   \\
 &\livelink{chap:DECL}{DECL}   \\
 &\DWATdefaultvalue{}   \\
 &\DWATdescription{}   \\
-&\DWATname{}   \\
-&\DWATsibling{}   \\
-&\DWATtype{}   \\
+&\DWATname{}      \\*
+&\DWATsibling{}   \\*
+&\DWATtype{}      \\*
 
 \hline
 \DWTAGtemplatevalueparameter{} 
 
 \hline
 \DWTAGtemplatevalueparameter{} 
@@ -838,9 +863,9 @@ means include all three of the
 &\DWATabstractorigin{}   \\
 &\DWATaccessibility{}   \\
 &\DWATdeclaration{}   \\
 &\DWATabstractorigin{}   \\
 &\DWATaccessibility{}   \\
 &\DWATdeclaration{}   \\
-&\DWATdiscr{}   \\
-&\DWATsibling{}   \\
-&\DWATtype{}   \\
+&\DWATdiscr{}   \\*
+&\DWATsibling{} \\*
+&\DWATtype{}    \\*
 
 \hline
 \DWTAGvolatiletype{}  
 
 \hline
 \DWTAGvolatiletype{}  
index 122a7cb..2cb8f2b 100644 (file)
@@ -15,6 +15,8 @@ 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
+5/13/2014       & 100909.1 (entry values), 100909.2 (call sites) \\
+4/25/2014       & 140330.1 (C++:2011), 14037.1 (enumeraion 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) \\
 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) \\
index ba2b690..9306573 100644 (file)
@@ -607,7 +607,8 @@ this is an 8\dash byte unsigned length
 \subsection{Debugging Information Entry}
 \label{datarep:debugginginformationentry}
 
 \subsection{Debugging Information Entry}
 \label{datarep:debugginginformationentry}
 
-Each debugging information entry begins with an unsigned LEB128
+Each debugging information entry begins with an 
+unsigned LEB128\addtoindexx{LEB128!unsigned}
 number containing the abbreviation code for the entry. This
 code represents an entry within the abbreviations table
 associated with the compilation unit containing this entry. The
 number containing the abbreviation code for the entry. This
 code represents an entry within the abbreviations table
 associated with the compilation unit containing this entry. The
@@ -633,13 +634,14 @@ The abbreviations table for a single compilation unit consists
 of a series of abbreviation declarations. Each declaration
 specifies the tag and attributes for a particular form of
 debugging information entry. Each declaration begins with
 of a series of abbreviation declarations. Each declaration
 specifies the tag and attributes for a particular form of
 debugging information entry. Each declaration begins with
-an unsigned LEB128 number representing the abbreviation
+an unsigned LEB128\addtoindexx{LEB128!unsigned}
+number representing the abbreviation
 code itself. It is this code that appears at the beginning
 of a debugging information entry in the 
 \dotdebuginfo{}
 section. As described above, the abbreviation
 code 0 is reserved for null debugging information entries. The
 code itself. It is this code that appears at the beginning
 of a debugging information entry in the 
 \dotdebuginfo{}
 section. As described above, the abbreviation
 code 0 is reserved for null debugging information entries. The
-abbreviation code is followed by another unsigned LEB128
+abbreviation code is followed by another unsigned LEB128\addtoindexx{LEB128!unsigned}
 number that encodes the entry\textquoteright s tag. The encodings for the
 tag names are given in 
 Table \refersec{tab:tagencodings}.
 number that encodes the entry\textquoteright s tag. The encodings for the
 tag names are given in 
 Table \refersec{tab:tagencodings}.
@@ -714,13 +716,15 @@ Table \refersec{tab:tagencodings}.
 \DWTAGimportedunit&0x3d      \\
 \DWTAGcondition&\xiiif      \\
 \DWTAGsharedtype&0x40      \\
 \DWTAGimportedunit&0x3d      \\
 \DWTAGcondition&\xiiif      \\
 \DWTAGsharedtype&0x40      \\
-\DWTAGtypeunit{} &0x41      \\
-\DWTAGrvaluereferencetype{} &0x42      \\
-\DWTAGtemplatealias{} &0x43      \\
-\DWTAGcoarraytype~\ddag &0x44 \\
-\DWTAGgenericsubrange~\ddag &0x45 \\
+\DWTAGtypeunit & 0x41      \\
+\DWTAGrvaluereferencetype & 0x42      \\
+\DWTAGtemplatealias & 0x43      \\
+\DWTAGcoarraytype~\ddag & 0x44 \\
+\DWTAGgenericsubrange~\ddag & 0x45 \\
 \DWTAGdynamictype~\ddag & 0x46 \\
 \DWTAGatomictype~\ddag & 0x47 \\
 \DWTAGdynamictype~\ddag & 0x46 \\
 \DWTAGatomictype~\ddag & 0x47 \\
+\DWTAGcallsite~\ddag & 0x48 \\
+\DWTAGcallsiteparameter~\ddag & 0x49 \\
 \DWTAGlouser&0x4080      \\
 \DWTAGhiuser&\xffff      \\
 \end{longtable}
 \DWTAGlouser&0x4080      \\
 \DWTAGhiuser&\xffff      \\
 \end{longtable}
@@ -767,10 +771,13 @@ each chain of sibling entries is terminated by a null entry.)
 \needlines{4}
 Finally, the child encoding is followed by a series of
 attribute specifications. Each attribute specification
 \needlines{4}
 Finally, the child encoding is followed by a series of
 attribute specifications. Each attribute specification
-consists of two parts. The first part is an unsigned LEB128
-number representing the attribute\textquoteright s name. The second part
-is an unsigned LEB128 number representing the attribute\textquoteright s
-form. The series of attribute specifications ends with an
+consists of two parts. The first part is an 
+unsigned LEB128\addtoindexx{LEB128!unsigned}
+number representing the attribute\textquoteright s name. 
+The second part is an 
+unsigned LEB128\addtoindexx{LEB128!unsigned} 
+number representing the attribute\textquoteright s form. 
+The series of attribute specifications ends with an
 entry containing 0 for the name and 0 for the form.
 
 The attribute form 
 entry containing 0 for the name and 0 for the form.
 
 The attribute form 
@@ -907,7 +914,8 @@ information bytes (\DWFORMblockfourTARG).
 \end{myindentpara}
 
 \begin{myindentpara}{1cm}
 \end{myindentpara}
 
 \begin{myindentpara}{1cm}
-An unsigned LEB128 length followed by the number of bytes
+An unsigned LEB128\addtoindexx{LEB128!unsigned}
+length followed by the number of bytes
 specified by the length (\DWFORMblockTARG).
 \end{myindentpara}
 
 specified by the length (\DWFORMblockTARG).
 \end{myindentpara}
 
@@ -956,7 +964,7 @@ unsigned integers respectively, rather than
 \needlines{4}
 \item \livelinki{chap:classexprloc}{exprloc}{exprloc class} \\
 \livetarg{datarep:classexprloc}{}
 \needlines{4}
 \item \livelinki{chap:classexprloc}{exprloc}{exprloc class} \\
 \livetarg{datarep:classexprloc}{}
-This is an unsigned LEB128 length followed by the
+This is an unsigned LEB128\addtoindexx{LEB128!unsigned} length followed by the
 number of information bytes specified by the length
 (\DWFORMexprlocTARG). 
 The information bytes contain a DWARF expression 
 number of information bytes specified by the length
 (\DWFORMexprlocTARG). 
 The information bytes contain a DWARF expression 
@@ -1084,7 +1092,8 @@ length forms for one, two, four and eight byte offsets
 \DWFORMreffourTARG,
 and \DWFORMrefeightTARG). 
 There is also an unsigned variable
 \DWFORMreffourTARG,
 and \DWFORMrefeightTARG). 
 There is also an unsigned variable
-length offset encoded form that uses unsigned LEB128 numbers
+length offset encoded form that uses 
+unsigned LEB128\addtoindexx{LEB128!unsigned} numbers
 (\DWFORMrefudataTARG). 
 Because this type of reference is within
 the containing compilation unit no relocation of the value
 (\DWFORMrefudataTARG). 
 Because this type of reference is within
 the containing compilation unit no relocation of the value
@@ -1464,10 +1473,10 @@ Table \refersec{tab:attributeformencodings}.
             \addtoindexx{enumeration class attribute!encoding}  \\
 \DWATlinkagename{} &0x6e&\livelink{chap:classstring}{string} 
             \addtoindexx{linkage name attribute!encoding}  \\
             \addtoindexx{enumeration class attribute!encoding}  \\
 \DWATlinkagename{} &0x6e&\livelink{chap:classstring}{string} 
             \addtoindexx{linkage name attribute!encoding}  \\
-\DWATstringlengthbitsize{} \ddag&0x6f&
+\DWATstringlengthbitsize{}~\ddag&0x6f&
                \livelink{chap:classconstant}{constant}
             \addtoindexx{string length attribute!size of length}  \\
                \livelink{chap:classconstant}{constant}
             \addtoindexx{string length attribute!size of length}  \\
-\DWATstringlengthbytesize{} \ddag&0x70&
+\DWATstringlengthbytesize{}~\ddag&0x70&
                \livelink{chap:classconstant}{constant}
             \addtoindexx{string length attribute!size of length}  \\
 \DWATrank~\ddag&0x71&
                \livelink{chap:classconstant}{constant}
             \addtoindexx{string length attribute!size of length}  \\
 \DWATrank~\ddag&0x71&
@@ -1494,7 +1503,33 @@ Table \refersec{tab:attributeformencodings}.
 \DWATrvaluereference~\ddag &0x78&
         \livelink{chap:DWATrvaluereference}{flag} \\
 \DWATmacros~\ddag &0x79&\livelink{chap:classmacptr}{macptr} 
 \DWATrvaluereference~\ddag &0x78&
         \livelink{chap:DWATrvaluereference}{flag} \\
 \DWATmacros~\ddag &0x79&\livelink{chap:classmacptr}{macptr} 
-            \addtoindexx{macro information attribute!encoding}  \\
+        \addtoindexx{macro information attribute!encoding}  \\
+\DWATcallallcalls~\ddag &0x7a&\CLASSflag
+        \addtoindexx{all calls summary attribute!encoding}\\
+\DWATcallallsourcecalls~\ddag &0x7b &\CLASSflag
+        \addtoindexx{all source calls summary attribute!encoding} \\
+\DWATcallalltailcalls~\ddag &0x7c&\CLASSflag
+        \addtoindexx{all tail calls summary attribute!encoding} \\
+\DWATcalldatalocation~\ddag &0x7d&\CLASSexprloc
+        \addtoindexx{call data location attribute!encoding} \\
+\DWATcalldatavalue~\ddag &0x7e&\CLASSexprloc
+        \addtoindexx{call data value attribute!encoding} \\
+\DWATcallorigin~\ddag &0x7f &\CLASSexprloc
+        \addtoindexx{call origin attribute!encoding} \\
+\DWATcallparameter~\ddag &0x80 &\CLASSreference
+        \addtoindexx{call parameter attribute!encoding} \\
+\DWATcallpc~\ddag &0x81 &\CLASSaddress
+        \addtoindexx{call pc attribute!encoding} \\
+\DWATcallreturnpc~\ddag &0x82 &\CLASSaddress
+        \addtoindexx{call return pc attribute!encoding} \\
+\DWATcalltailcall~\ddag &0x83 &\CLASSflag
+        \addtoindexx{call tail call attribute!encoding} \\
+\DWATcalltarget~\ddag &0x84 &\CLASSexprloc
+        \addtoindexx{call target attribute!encoding} \\
+\DWATcalltargetclobbered!\ddag &0x85 &\CLASSexprloc
+        \addtoindexx{call target clobbered attribute!encoding} \\
+\DWATcallvalue~\ddag &0x86 &\CLASSexprloc
+        \addtoindexx{call value attribute!encoding} \\
 
 \DWATlouser&0x2000 & --- \addtoindexx{low user attribute encoding}  \\
 \DWAThiuser&\xiiifff& --- \addtoindexx{high user attribute encoding}  \\
 
 \DWATlouser&0x2000 & --- \addtoindexx{low user attribute encoding}  \\
 \DWAThiuser&\xiiifff& --- \addtoindexx{high user attribute encoding}  \\
@@ -1570,7 +1605,7 @@ avoids using space to represent the \doublequote{big} end of an
 unsigned integer, when the big end is all zeroes or sign
 extension bits.}
 
 unsigned integer, when the big end is all zeroes or sign
 extension bits.}
 
-Unsigned LEB128 (ULEB128) numbers are encoded as follows:
+Unsigned LEB128\addtoindexx{LEB128!unsigned} (ULEB128) numbers are encoded as follows:
 \addtoindexx{LEB128!unsigned, encoding as}
 start at the low order end of an unsigned integer and chop
 it into 7\dash bit chunks. Place each chunk into the low order 7
 \addtoindexx{LEB128!unsigned, encoding as}
 start at the low order end of an unsigned integer and chop
 it into 7\dash bit chunks. Place each chunk into the low order 7
@@ -1585,7 +1620,8 @@ The integer zero is a special case, consisting of a single
 zero byte.
 
 Table \refersec{tab:examplesofunsignedleb128encodings}
 zero byte.
 
 Table \refersec{tab:examplesofunsignedleb128encodings}
-gives some examples of unsigned LEB128 numbers. The
+gives some examples of unsigned LEB128\addtoindexx{LEB128!unsigned}
+numbers. The
 0x80 in each case is the high order bit of the byte, indicating
 that an additional byte follows.
 
 0x80 in each case is the high order bit of the byte, indicating
 that an additional byte follows.
 
@@ -1603,9 +1639,9 @@ that there is nothing within the LEB128 representation that
 indicates whether an encoded number is signed or unsigned. The
 decoder must know what type of number to expect. 
 Table \refersec{tab:examplesofunsignedleb128encodings}
 indicates whether an encoded number is signed or unsigned. The
 decoder must know what type of number to expect. 
 Table \refersec{tab:examplesofunsignedleb128encodings}
-gives some examples of unsigned LEB128 numbers and 
-Table \refersec{tab:examplesofsignedleb128encodings}
-gives some examples of signed LEB128 
+gives some examples of unsigned LEB128\addtoindexx{LEB128!unsigned}
+numbers and Table \refersec{tab:examplesofsignedleb128encodings}
+gives some examples of signed LEB128\addtoindexx{LEB128!signed} 
 numbers.
 
 \textit{Appendix \refersec{app:variablelengthdataencodingdecodinginformative} 
 numbers.
 
 \textit{Appendix \refersec{app:variablelengthdataencodingdecodinginformative} 
@@ -1618,7 +1654,7 @@ gives algorithms for encoding and decoding these forms.}
 \begin{longtable}{l|l|l}
   \caption{Examples of unsigned LEB128 encodings}
   \label{tab:examplesofunsignedleb128encodings} 
 \begin{longtable}{l|l|l}
   \caption{Examples of unsigned LEB128 encodings}
   \label{tab:examplesofunsignedleb128encodings} 
-  \addtoindexx{LEB128 encoding!examples} \\
+  \addtoindexx{LEB128 encoding!examples}\addtoindexx{LEB128!unsigned} \\
   \hline \bfseries Number&\bfseries First byte &\bfseries Second byte \\ \hline
 \endfirsthead
   \bfseries Number&\bfseries First Byte &\bfseries Second byte\\ \hline
   \hline \bfseries Number&\bfseries First byte &\bfseries Second byte \\ \hline
 \endfirsthead
   \bfseries Number&\bfseries First Byte &\bfseries Second byte\\ \hline
@@ -1641,7 +1677,9 @@ gives algorithms for encoding and decoding these forms.}
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \begin{longtable}{l|l|l}
 \begin{centering}
 \setlength{\extrarowheight}{0.1cm}
 \begin{longtable}{l|l|l}
-  \caption{Examples of signed LEB128 encodings} \label{tab:examplesofsignedleb128encodings} \\
+  \caption{Examples of signed LEB128 encodings} 
+  \label{tab:examplesofsignedleb128encodings} 
+  \addtoindexx{LEB128!signed} \\
   \hline \bfseries Number&\bfseries First byte &\bfseries Second byte \\ \hline
 \endfirsthead
   \bfseries Number&\bfseries First Byte &\bfseries Second byte\\ \hline
   \hline \bfseries Number&\bfseries First byte &\bfseries Second byte \\ \hline
 \endfirsthead
   \bfseries Number&\bfseries First Byte &\bfseries Second byte\\ \hline
@@ -1779,6 +1817,8 @@ 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, \\*
+                   &&&\nolink{block} of that size\\
 \DWOPlouser{} &0xe0 && \\
 \DWOPhiuser{} &\xff && \\
 
 \DWOPlouser{} &0xe0 && \\
 \DWOPhiuser{} &\xff && \\
 
@@ -2073,35 +2113,37 @@ defined language.
   \hline
   \dag \ \textit{See text} \\ \ddag \ \textit{New in \addtoindex{DWARF Version 5}}
 \endlastfoot
   \hline
   \dag \ \textit{See text} \\ \ddag \ \textit{New in \addtoindex{DWARF Version 5}}
 \endlastfoot
-
-\DWLANGCeightynine &0x0001 &0       \\
-\DWLANGC{} &0x0002 &0  \\
-\DWLANGAdaeightythree{} \dag &0x0003 &1  \addtoindexx{Ada}     \\
-\DWLANGCplusplus{} &0x0004 &0       \\
-\DWLANGCobolseventyfour{} \dag &0x0005 &1       \\
-\DWLANGCoboleightyfive{} \dag &0x0006 &1       \\
-\DWLANGFortranseventyseven &0x0007 &1       \\
-\DWLANGFortranninety &0x0008 &1       \\
-\DWLANGPascaleightythree &0x0009 &1       \\
-\DWLANGModulatwo &0x000a &1       \\
-\DWLANGJava &0x000b &0       \\
-\DWLANGCninetynine &0x000c &0       \\
-\DWLANGAdaninetyfive{} \dag &0x000d &1 \addtoindexx{Ada}      \\
-\DWLANGFortranninetyfive &0x000e &1       \\
-\DWLANGPLI{} \dag &0x000f &1 \\
-\DWLANGObjC{} &0x0010 &0 \\
-\DWLANGObjCplusplus{} &0x0011 &0 \\
-\DWLANGUPC{} &0x0012 &0 \\
-\DWLANGD{} &0x0013 &0 \\
-\DWLANGPython{} \dag &0x0014 &0 \\
-\DWLANGOpenCL{} \dag \ddag &0x0015 &0 \\
-\DWLANGGo{} \dag \ddag &0x0016 &0 \\
-\DWLANGModulathree{} \dag \ddag &0x0017 &1 \\
-\DWLANGHaskell{} \dag \ddag &0x0018 &0 \\
-\DWLANGCpluspluszerothree{} \ddag &0x0019 &0 \\
-\DWLANGCpluspluseleven{} \ddag &0x001a &0 \\
-\DWLANGOCaml{} \ddag &0x001b &0        \\
-\DWLANGRust{} \ddag &0x001c &0 \\
+\addtoindexx{ISO-defined language names}
+
+\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)}      \\
+\DWLANGCobolseventyfour{} \dag &0x0005 &1 \addtoindexx{COBOL:1974 (ISO)}      \\
+\DWLANGCoboleightyfive{} \dag &0x0006 &1 \addtoindexx{COBOL:1985 (ISO)}      \\
+\DWLANGFortranseventyseven &0x0007 &1 \addtoindexx{FORTRAN:1977 (ISO)}      \\
+\DWLANGFortranninety &0x0008 &1 \addtoindexx{Fortran:1990 (ISO)}      \\
+\DWLANGPascaleightythree &0x0009 &1 \addtoindexx{Pascal:1983 (ISO)}      \\
+\DWLANGModulatwo &0x000a &1 \addtoindexx{Modula-2:1996 (ISO)}      \\
+\DWLANGJava &0x000b &0 \addtoindexx{Java}      \\
+\DWLANGCninetynine &0x000c &0 \addtoindexx{C:1999 (ISO)}      \\
+\DWLANGAdaninetyfive{} \dag &0x000d &1 \addtoindexx{Ada:1995 (ISO)}      \\
+\DWLANGFortranninetyfive &0x000e &1 \addtoindexx{Fortran:1995 (ISO)}      \\
+\DWLANGPLI{} \dag &0x000f &1 \addtoindexx{PL/I:1976 (ANSI)}\\
+\DWLANGObjC{} &0x0010 &0 \addtoindexx{Objective C}\\
+\DWLANGObjCplusplus{} &0x0011 &0 \addtoindexx{Objective C++}\\
+\DWLANGUPC{} &0x0012 &0 \addtoindexx{UPC}\\
+\DWLANGD{} &0x0013 &0 \addtoindexx{D language}\\
+\DWLANGPython{} \dag &0x0014 &0 \addtoindexx{Python}\\
+\DWLANGOpenCL{} \dag \ddag &0x0015 &0 \addtoindexx{OpenCL}\\
+\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)}\\
+\DWLANGOCaml{} \ddag &0x001b &0        \addtoindexx{OCaml}\\
+\DWLANGRust{} \ddag &0x001c &0 \addtoindexx{Rust}\\
+\DWLANGCeleven{} \ddag &0x001d &0 \addtoindexx{C:2011 (ISO)}\\
 \DWLANGlouser{} &0x8000 & \\
 \DWLANGhiuser{} &\xffff & \\
 
 \DWLANGlouser{} &0x8000 & \\
 \DWLANGhiuser{} &\xffff & \\
 
@@ -2511,8 +2553,8 @@ Table \refersec{tab:linenumberfileentryformatencodings}.
 \label{datarep:macroinformation}
 
 The source line numbers and source file indices encoded in the
 \label{datarep:macroinformation}
 
 The source line numbers and source file indices encoded in the
-macro information section are represented as unsigned LEB128
-numbers.
+macro information section are represented as 
+unsigned LEB128\addtoindexx{LEB128!unsigned} numbers.
 
 The macro information entry type is encoded as a single byte. 
 The encodings 
 
 The macro information entry type is encoded as a single byte. 
 The encodings 
@@ -2919,7 +2961,7 @@ Table \ref{tab:integerrepresentationnames}.
 \label{datarep:typesignaturecomputation}
 
 A type signature is computed only by the DWARF producer;
 \label{datarep:typesignaturecomputation}
 
 A type signature is computed only by the DWARF producer;
-\addtoindexx{type signature computation}
+\addtoindexx{type signature!computation}
 it is used by a DWARF consumer to resolve type references to
 the type definitions that are contained in 
 \addtoindexx{type unit}
 it is used by a DWARF consumer to resolve type references to
 the type definitions that are contained in 
 \addtoindexx{type unit}
@@ -3036,8 +3078,8 @@ in their own alphabetical suborder.
 
 An attribute that refers to another type entry T is processed
 as follows: (a) If T is in the list V at some V[x], use the
 
 An attribute that refers to another type entry T is processed
 as follows: (a) If T is in the list V at some V[x], use the
-letter 'R' as the marker and use the unsigned LEB128 encoding
-of x as the attribute value; otherwise, (b) use the letter 'T'
+letter 'R' as the marker and use the unsigned LEB128\addtoindexx{LEB128!unsigned}
+encoding of x as the attribute value; otherwise, (b) use the letter 'T'
 as the marker, process the type T recursively by performing
 Steps 2 through 7, and use the result as the attribute value.
 
 as the marker, process the type T recursively by performing
 Steps 2 through 7, and use the result as the attribute value.
 
@@ -3110,8 +3152,8 @@ both S and D, the attribute in S is used and the corresponding
 one in D is ignored.
 
 DWARF tag and attribute codes are appended to the sequence
 one in D is ignored.
 
 DWARF tag and attribute codes are appended to the sequence
-as unsigned LEB128 values, using the values defined earlier
-in this chapter.
+as unsigned LEB128\addtoindexx{LEB128!unsigned} values, 
+using the values defined earlier in this chapter.
 
 \textit{A grammar describing this computation may be found in
 Appendix \refersec{app:typesignaturecomputationgrammar}.
 
 \textit{A grammar describing this computation may be found in
 Appendix \refersec{app:typesignaturecomputationgrammar}.
index 2774cfa..ffbb735 100644 (file)
@@ -53,8 +53,11 @@ versus \dotdebuginfodwo).}
                                                                          \end{tabular}};
 \node(zlinki)   at (5,  6.7)  [link] {\DWATmacros{}~~(g)};
 \node(zlinkj)   at (5,  5.4)  [link] {\DWATstmtlist{}~~(h)};
                                                                          \end{tabular}};
 \node(zlinki)   at (5,  6.7)  [link] {\DWATmacros{}~~(g)};
 \node(zlinkj)   at (5,  5.4)  [link] {\DWATstmtlist{}~~(h)};
-\node(zlinkh)   at (5,  4.1)  [link] {\DWATranges{}~~(i)};
-\node(zlinkg)   at (5,  2.8)  [link] {\DWATlocation{}, etc.~~(j)};
+\node(zlinkh)   at (5,  3.9)  [link] {\begin{tabular}{c}
+                                      \DWATranges{}~~~~(i) \\
+                                      \DWATrangesbase
+                                      \end{tabular}};
+\node(zlinkg)   at (5,  2.4)  [link] {\DWATlocation{}, etc.~~(j)};
 \node(zlinkk)  at (5,  0.5)  [link] {\begin{tabular}(c)
                                                                          \DWATaddrbase    \\
                                                                          \DWFORMaddrx \\
 \node(zlinkk)  at (5,  0.5)  [link] {\begin{tabular}(c)
                                                                          \DWATaddrbase    \\
                                                                          \DWFORMaddrx \\
@@ -248,13 +251,13 @@ are offsets to the corresponding string text in the
 %m
 \item \dotdebugmacro{} to \dotdebugstroffsets \\
 The second operand of a 
 %m
 \item \dotdebugmacro{} to \dotdebugstroffsets \\
 The second operand of a 
-\DWMACROdefineindirect macroinfo
+\DWMACROdefineindirect{} macroinfo
 entry is an index into the string table in the 
 \dotdebugstr{} section.
 
 
 %n
 entry is an index into the string table in the 
 \dotdebugstr{} section.
 
 
 %n
-\item \dotdebugmacro to \dotdebugline \\
+\item \dotdebugmacro{} to \dotdebugline \\
 The second operand of 
 \DWMACROstartfile{} refers to a file entry in the 
 \dotdebugline{} section relative to the start 
 The second operand of 
 \DWMACROstartfile{} refers to a file entry in the 
 \dotdebugline{} section relative to the start 
@@ -271,7 +274,7 @@ section.
 %p
 \item \dotdebugmacro{} to \dotdebugstroffsets \\
 The second operand of a 
 %p
 \item \dotdebugmacro{} to \dotdebugstroffsets \\
 The second operand of a 
-\DWMACROdefineindirectx macroinfo entry is an index
+\DWMACROdefineindirectx{} macroinfo entry is an index
 into the string offset table in the 
 \dotdebugstroffsets{} section.
 
 into the string offset table in the 
 \dotdebugstroffsets{} section.
 
index 8ac192a..fd2c3a7 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}{April 19, 2014}
+\newcommand{\docdate}{May 13, 2014}
 %
 \usepackage{ifthen}
 \newboolean{isdraft}
 %
 \usepackage{ifthen}
 \newboolean{isdraft}
@@ -321,12 +321,12 @@ escapeinside={\%*}{*)}     % if you want to add a comment within your code
 %  The \appendix toggles us into appendix chapters
 \appendix
 
 %  The \appendix toggles us into appendix chapters
 \appendix
 
-\include{attributesbytag}                              \emptypage
-\include{debugsectionrelationships}     \emptypage
-\include{encodingdecoding}              %\emptypage
+\include{attributesbytag}              %\emptypage
+\include{debugsectionrelationships}     %\emptypage
+\include{encodingdecoding}              \emptypage
 \include{examples}                      %\emptypage
 \include{compression}                   %\emptypage
 \include{examples}                      %\emptypage
 \include{compression}                   %\emptypage
-\include{splitobjects}                                 %\emptypage
+\include{splitobjects}                 %\emptypage
 \include{sectionversionnumbers}
 \include{gnulicense}
 
 \include{sectionversionnumbers}
 \include{gnulicense}
 
index 18b5fc4..952221d 100644 (file)
@@ -9,8 +9,8 @@
        \expandafter\def\csname #1LINK\endcsname{\index{#2}\hyperlink{chap:#1}{#2}}
        \expandafter\def\csname #1TARG\endcsname{\index{#2}\hypertarget{chap:#1}{#2}}
        \expandafter\def\csname #1INDX\endcsname{\index{#2}}
        \expandafter\def\csname #1LINK\endcsname{\index{#2}\hyperlink{chap:#1}{#2}}
        \expandafter\def\csname #1TARG\endcsname{\index{#2}\hypertarget{chap:#1}{#2}}
        \expandafter\def\csname #1INDX\endcsname{\index{#2}}
-       \expandafter\def\csname #1MARK\endcsname{\hypertarget{chap:#1}{}\index{#2}}     
-       \expandafter\def\csname #1NAME\endcsname{#2}
+       \expandafter\def\csname #1MARK\endcsname{\index{#2}\hypertarget{chap:#1}{}}     
+       \expandafter\def\csname #1NAME\endcsname{\index{#2}{#2}}
        % The normal, most common use in running text...
        \expandafter\def\csname #1\endcsname{\csname #1LINK\endcsname}
        }
        % The normal, most common use in running text...
        \expandafter\def\csname #1\endcsname{\csname #1LINK\endcsname}
        }
 \newdwfnamecommands{DWATbytesize}{DW\_AT\_byte\_size}
 \newdwfnamecommands{DWATbytestride}{DW\_AT\_byte\_stride}
 %
 \newdwfnamecommands{DWATbytesize}{DW\_AT\_byte\_size}
 \newdwfnamecommands{DWATbytestride}{DW\_AT\_byte\_stride}
 %
+\newdwfnamecommands{DWATcallallcalls}{DW\_AT\_call\_all\_calls}
+\newdwfnamecommands{DWATcallallsourcecalls}{DW\_AT\_call\_all\_source\_calls}
+\newdwfnamecommands{DWATcallalltailcalls}{DW\_AT\_call\_all\_tail\_calls}
 \newdwfnamecommands{DWATcallcolumn}{DW\_AT\_call\_column}
 \newdwfnamecommands{DWATcallcolumn}{DW\_AT\_call\_column}
+\newdwfnamecommands{DWATcalldatalocation}{DW\_AT\_call\_data\_location}
+\newdwfnamecommands{DWATcalldatavalue}{DW\_AT\_call\_data\_value}
 \newdwfnamecommands{DWATcallfile}{DW\_AT\_call\_file}
 \newdwfnamecommands{DWATcallline}{DW\_AT\_call\_line}
 \newdwfnamecommands{DWATcallfile}{DW\_AT\_call\_file}
 \newdwfnamecommands{DWATcallline}{DW\_AT\_call\_line}
+\newdwfnamecommands{DWATcallorigin}{DW\_AT\_call\_origin}
+\newdwfnamecommands{DWATcallparameter}{DW\_AT\_call\_parameter}
+\newdwfnamecommands{DWATcallpc}{DW\_AT\_call\_pc}
+\newdwfnamecommands{DWATcallreturnpc}{DW\_AT\_call\_return\_pc}
+\newdwfnamecommands{DWATcalltailcall}{DW\_AT\_call\_tail\_call}
+\newdwfnamecommands{DWATcalltarget}{DW\_AT\_call\_target}
+\newdwfnamecommands{DWATcalltargetclobbered}{DW\_AT\_call\_target\_clobbered}
+\newdwfnamecommands{DWATcallvalue}{DW\_AT\_call\_value}
 \newdwfnamecommands{DWATcallingconvention}{DW\_AT\_calling\_convention}
 \newdwfnamecommands{DWATcommonreference}{DW\_AT\_common\_reference}
 \newdwfnamecommands{DWATcompdir}{DW\_AT\_comp\_dir}
 \newdwfnamecommands{DWATcallingconvention}{DW\_AT\_calling\_convention}
 \newdwfnamecommands{DWATcommonreference}{DW\_AT\_common\_reference}
 \newdwfnamecommands{DWATcompdir}{DW\_AT\_comp\_dir}
 \newdwfnamecommands{DWLANGC}{DW\_LANG\_C}
 \newdwfnamecommands{DWLANGCeightynine}{DW\_LANG\_C89}
 \newdwfnamecommands{DWLANGCninetynine}{DW\_LANG\_C99}
 \newdwfnamecommands{DWLANGC}{DW\_LANG\_C}
 \newdwfnamecommands{DWLANGCeightynine}{DW\_LANG\_C89}
 \newdwfnamecommands{DWLANGCninetynine}{DW\_LANG\_C99}
+\newdwfnamecommands{DWLANGCeleven}{DW\_LANG\_C11}
 \newdwfnamecommands{DWLANGCplusplus}{DW\_LANG\_C\_plus\_plus}
 \newdwfnamecommands{DWLANGCobolseventyfour}{DW\_LANG\_Cobol74}
 \newdwfnamecommands{DWLANGCoboleightyfive}{DW\_LANG\_Cobol85}
 \newdwfnamecommands{DWLANGCplusplus}{DW\_LANG\_C\_plus\_plus}
 \newdwfnamecommands{DWLANGCobolseventyfour}{DW\_LANG\_Cobol74}
 \newdwfnamecommands{DWLANGCoboleightyfive}{DW\_LANG\_Cobol85}
 \newdwfnamecommands{DWOPbregn}{DW\_OP\_breg<n>}                                                                        % Generic DW_OP_breg[0..31] name
 \newdwfnamecommands{DWOPbregzero}{DW\_OP\_breg0}
 \newdwfnamecommands{DWOPbregone}{DW\_OP\_breg1}
 \newdwfnamecommands{DWOPbregn}{DW\_OP\_breg<n>}                                                                        % Generic DW_OP_breg[0..31] name
 \newdwfnamecommands{DWOPbregzero}{DW\_OP\_breg0}
 \newdwfnamecommands{DWOPbregone}{DW\_OP\_breg1}
-\newdwfnamecommands{DWOPbregthirtyone}{DW\_OP\_breg31}
        \newcommand{\DWOPbregtwo}{\hyperlink{chap:DWOPbregn}{DW\_OP\_breg2}}            % Link, don't index...
        \newcommand{\DWOPbregthree}{\hyperlink{chap:DWOPbregn}{DW\_OP\_breg3}}          %
        \newcommand{\DWOPbregfour}{\hyperlink{chap:DWOPbregn}{DW\_OP\_breg4}}           %
        \newcommand{\DWOPbregfive}{\hyperlink{chap:DWOPbregn}{DW\_OP\_breg5}}           %
        \newcommand{\DWOPbregeleven}{\hyperlink{chap:DWOPbregn}{DW\_OP\_breg11}}        %
        \newcommand{\DWOPbregtwo}{\hyperlink{chap:DWOPbregn}{DW\_OP\_breg2}}            % Link, don't index...
        \newcommand{\DWOPbregthree}{\hyperlink{chap:DWOPbregn}{DW\_OP\_breg3}}          %
        \newcommand{\DWOPbregfour}{\hyperlink{chap:DWOPbregn}{DW\_OP\_breg4}}           %
        \newcommand{\DWOPbregfive}{\hyperlink{chap:DWOPbregn}{DW\_OP\_breg5}}           %
        \newcommand{\DWOPbregeleven}{\hyperlink{chap:DWOPbregn}{DW\_OP\_breg11}}        %
+\newdwfnamecommands{DWOPbregthirtyone}{DW\_OP\_breg31}
 \newdwfnamecommands{DWOPbregx}{DW\_OP\_bregx}
 \newdwfnamecommands{DWOPcalltwo}{DW\_OP\_call2}
 \newdwfnamecommands{DWOPcallfour}{DW\_OP\_call4}
 \newdwfnamecommands{DWOPcallframecfa}{DW\_OP\_call\_frame\_cfa}
 \newdwfnamecommands{DWOPcallref}{DW\_OP\_call\_ref}
 \newdwfnamecommands{DWOPbregx}{DW\_OP\_bregx}
 \newdwfnamecommands{DWOPcalltwo}{DW\_OP\_call2}
 \newdwfnamecommands{DWOPcallfour}{DW\_OP\_call4}
 \newdwfnamecommands{DWOPcallframecfa}{DW\_OP\_call\_frame\_cfa}
 \newdwfnamecommands{DWOPcallref}{DW\_OP\_call\_ref}
-\newdwfnamecommands{DWOPconstnx}{DW\_OP\_const<n><x>}                                                  % Generic const[1248[su] operator name
-\newdwfnamecommands{DWOPconstns}{DW\_OP\_const<n>s}                                                            % Generic const[1248]s operator name
-\newdwfnamecommands{DWOPconstnu}{DW\_OP\_const<n>u}                                                            % Generic const[1248]u operator name
+\newdwfnamecommands{DWOPconstnx}{DW\_OP\_const<n><x>}                          % Generic const[1248][su] operator name
+\newdwfnamecommands{DWOPconstns}{DW\_OP\_const<n>s}                            % Generic const[1248]s operator name
+\newdwfnamecommands{DWOPconstnu}{DW\_OP\_const<n>u}                            % Generic const[1248]u operator name
 \newdwfnamecommands{DWOPconstones}{DW\_OP\_const1s}
 \newdwfnamecommands{DWOPconstoneu}{DW\_OP\_const1u}
 \newdwfnamecommands{DWOPconsttwos}{DW\_OP\_const2s}
 \newdwfnamecommands{DWOPconstones}{DW\_OP\_const1s}
 \newdwfnamecommands{DWOPconstoneu}{DW\_OP\_const1u}
 \newdwfnamecommands{DWOPconsttwos}{DW\_OP\_const2s}
 \newdwfnamecommands{DWOPdiv}{DW\_OP\_div}
 \newdwfnamecommands{DWOPdrop}{DW\_OP\_drop}
 \newdwfnamecommands{DWOPdup}{DW\_OP\_dup}
 \newdwfnamecommands{DWOPdiv}{DW\_OP\_div}
 \newdwfnamecommands{DWOPdrop}{DW\_OP\_drop}
 \newdwfnamecommands{DWOPdup}{DW\_OP\_dup}
+\newdwfnamecommands{DWOPentryvalue}{DW\_OP\_entry\_value}
 \newdwfnamecommands{DWOPeq}{DW\_OP\_eq}
 \newdwfnamecommands{DWOPfbreg}{DW\_OP\_fbreg}
 \newdwfnamecommands{DWOPformtlsaddress}{DW\_OP\_form\_tls\_address}
 \newdwfnamecommands{DWOPeq}{DW\_OP\_eq}
 \newdwfnamecommands{DWOPfbreg}{DW\_OP\_fbreg}
 \newdwfnamecommands{DWOPformtlsaddress}{DW\_OP\_form\_tls\_address}
 \newdwfnamecommands{DWOPimplicitpointer}{DW\_OP\_implicit\_pointer}
 \newdwfnamecommands{DWOPimplicitvalue}{DW\_OP\_implicit\_value}
 \newdwfnamecommands{DWOPle}{DW\_OP\_le}
 \newdwfnamecommands{DWOPimplicitpointer}{DW\_OP\_implicit\_pointer}
 \newdwfnamecommands{DWOPimplicitvalue}{DW\_OP\_implicit\_value}
 \newdwfnamecommands{DWOPle}{DW\_OP\_le}
-\newdwfnamecommands{DWOPlitn}{DW\_OP\_lit<n>}                                                          % generic DW_OP_lit[0..31] name
+\newdwfnamecommands{DWOPlitn}{DW\_OP\_lit<n>}                                  % generic DW_OP_lit[0..31] name
 \newdwfnamecommands{DWOPlitzero}{DW\_OP\_lit0}
 \newdwfnamecommands{DWOPlitone}{DW\_OP\_lit1}
     \newcommand{\DWOPlittwo}{\hyperlink{chap:DWOPlitn}{DW\_OP\_lit2}}          % Link, don't index...
     \newcommand{\DWOPlitthree}{\hyperlink{chap:DWOPlitn}{DW\_OP\_lit3}}                % Link, don't index...
 \newdwfnamecommands{DWOPlitzero}{DW\_OP\_lit0}
 \newdwfnamecommands{DWOPlitone}{DW\_OP\_lit1}
     \newcommand{\DWOPlittwo}{\hyperlink{chap:DWOPlitn}{DW\_OP\_lit2}}          % Link, don't index...
     \newcommand{\DWOPlitthree}{\hyperlink{chap:DWOPlitn}{DW\_OP\_lit3}}                % Link, don't index...
+    \newcommand{\DWOPlitfour}{\hyperlink{chap:DWOPlitn}{DW\_OP\_lit4}}         % Link, don't index...
+    \newcommand{\DWOPlitfive}{\hyperlink{chap:DWOPlitn}{DW\_OP\_lit5}}         % Link, don't index...
 \newdwfnamecommands{DWOPlitthirtyone}{DW\_OP\_lit31}
 \newdwfnamecommands{DWOPlouser}{DW\_OP\_lo\_user}
 \newdwfnamecommands{DWOPlt}{DW\_OP\_lt}
 \newdwfnamecommands{DWOPlitthirtyone}{DW\_OP\_lit31}
 \newdwfnamecommands{DWOPlouser}{DW\_OP\_lo\_user}
 \newdwfnamecommands{DWOPlt}{DW\_OP\_lt}
 \newdwfnamecommands{DWOPplus}{DW\_OP\_plus}
 \newdwfnamecommands{DWOPplusuconst}{DW\_OP\_plus\_uconst}
 \newdwfnamecommands{DWOPpushobjectaddress}{DW\_OP\_push\_object\_address}
 \newdwfnamecommands{DWOPplus}{DW\_OP\_plus}
 \newdwfnamecommands{DWOPplusuconst}{DW\_OP\_plus\_uconst}
 \newdwfnamecommands{DWOPpushobjectaddress}{DW\_OP\_push\_object\_address}
-\newdwfnamecommands{DWOPregn}{DW\_OP\_reg<n>}                                                                  % Generic DW_OP_reg[0..31] name
+\newdwfnamecommands{DWOPregn}{DW\_OP\_reg<n>}                                  % Generic DW_OP_reg[0..31] name
 \newdwfnamecommands{DWOPregzero}{DW\_OP\_reg0}
 \newdwfnamecommands{DWOPregone}{DW\_OP\_reg1}
 \newdwfnamecommands{DWOPregzero}{DW\_OP\_reg0}
 \newdwfnamecommands{DWOPregone}{DW\_OP\_reg1}
-       \newcommand{\DWOPregtwo}{\hyperlink{chap:DWOPregn}{DW\_OP\_reg2}}                       % Link, don't index
+       \newcommand{\DWOPregtwo}{\hyperlink{chap:DWOPregn}{DW\_OP\_reg2}}       % Link, don't index
        \newcommand{\DWOPregthree}{\hyperlink{chap:DWOPregn}{DW\_OP\_reg3}}
        \newcommand{\DWOPregthree}{\hyperlink{chap:DWOPregn}{DW\_OP\_reg3}}
+        \newcommand{\DWOPregfour}{\hyperlink{chap:DWOPregn}{DW\_OP\_reg4}}
        \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{DWTAGarraytype}{DW\_TAG\_array\_type}
 \newdwfnamecommands{DWTAGatomictype}{DW\_TAG\_atomic\_type}
 \newdwfnamecommands{DWTAGbasetype}{DW\_TAG\_base\_type}
 \newdwfnamecommands{DWTAGarraytype}{DW\_TAG\_array\_type}
 \newdwfnamecommands{DWTAGatomictype}{DW\_TAG\_atomic\_type}
 \newdwfnamecommands{DWTAGbasetype}{DW\_TAG\_base\_type}
+\newdwfnamecommands{DWTAGcallsite}{DW\_TAG\_call\_site}
+\newdwfnamecommands{DWTAGcallsiteparameter}{DW\_TAG\_call\_site\_parameter}
 \newdwfnamecommands{DWTAGcatchblock}{DW\_TAG\_catch\_block}
 \newdwfnamecommands{DWTAGclasstype}{DW\_TAG\_class\_type}
 \newdwfnamecommands{DWTAGcoarraytype}{DW\_TAG\_coarray\_type}
 \newdwfnamecommands{DWTAGcatchblock}{DW\_TAG\_catch\_block}
 \newdwfnamecommands{DWTAGclasstype}{DW\_TAG\_class\_type}
 \newdwfnamecommands{DWTAGcoarraytype}{DW\_TAG\_coarray\_type}
 %
 % DWARF Classes of Attribute Value
 %
 %
 % DWARF Classes of Attribute Value
 %
-\newcommand{\CLASSaddress}      {\addtoindexi{address}{address class}}
-\newcommand{\CLASSaddrptr}      {\addtoindexi{addrptr}{addrptr class}}
-\newcommand{\CLASSblock}        {\addtoindexi{block}{block class}}
-\newcommand{\CLASSconstant}     {\addtoindexi{constant}{constant class}}
-\newcommand{\CLASSexprloc}      {\addtoindexi{exprloc}{exprloc class}}
-\newcommand{\CLASSflag}         {\addtoindexi{flag}{flag class}}
-\newcommand{\CLASSlineptr}      {\addtoindexi{lineptr}{lineptr class}}
-\newcommand{\CLASSloclistptr}   {\addtoindexi{loclistptr}{loclistptr class}}
-\newcommand{\CLASSmacptr}       {\addtoindexi{macptr}{macptr class}}
-\newcommand{\CLASSrangelistptr} {\addtoindexi{rangelistptr}{rangelistptr class}}
-\newcommand{\CLASSreference}    {\addtoindexi{reference}{reference class}}
-\newcommand{\CLASSstring}       {\addtoindexi{string}{string class}}
-\newcommand{\CLASSstroffsetsptr}{\addtoindexi{stroffsetsptr}{stroffsetsptr class}}
+\newcommand{\CLASSaddress}      {\livelinki{chap:address}{address}{address class}}
+\newcommand{\CLASSaddrptr}      {\livelinki{chap:addrptr}{addrptr}{addrptr class}}
+\newcommand{\CLASSblock}        {\livelinki{chap:block}{block}{block class}}
+\newcommand{\CLASSconstant}     {\livelinki{chap:constant}{constant}{constant class}}
+\newcommand{\CLASSexprloc}      {\livelinki{chap:exprloc}{exprloc}{exprloc class}}
+\newcommand{\CLASSflag}         {\livelinki{chap:flag}{flag}{flag class}}
+\newcommand{\CLASSlineptr}      {\livelinki{chap:lineptr}{lineptr}{lineptr class}}
+\newcommand{\CLASSloclistptr}   {\livelinki{chap:loclistptr}{loclistptr}{loclistptr class}}
+\newcommand{\CLASSmacptr}       {\livelinki{chap:macptr}{macptr}{macptr class}}
+\newcommand{\CLASSrangelistptr} {\livelinki{chap:rangelistptr}{rangelistptr}{rangelistptr class}}
+\newcommand{\CLASSreference}    {\livelinki{chap:reference}{reference}{reference class}}
+\newcommand{\CLASSstring}       {\livelinki{chap:string}{string}{string class}}
+\newcommand{\CLASSstroffsetsptr}{\livelinki{chap:stroffsetsptr}{stroffsetsptr}{stroffsetsptr class}}
 %
 % Miscellaneous
 %
 %
 % Miscellaneous
 %
index 026e356..7ab8382 100644 (file)
@@ -1308,7 +1308,7 @@ Figure~\ref{fig:namespaceexampledwarfdescription}: Namespace example: DWARF desc
 \clearpage
 \section{Member Function Examples}
 \label{app:memberfunctionexample}
 \clearpage
 \section{Member Function Examples}
 \label{app:memberfunctionexample}
-
+\addtoindexx{member function example}
 Consider the member function example fragment in 
 Figure \refersec{fig:memberfunctionexamplesourcefragment}.
 The DWARF representation in 
 Consider the member function example fragment in 
 Figure \refersec{fig:memberfunctionexamplesourcefragment}.
 The DWARF representation in 
@@ -1437,7 +1437,7 @@ void g() {
     auto pointer_to_member_function = &A::f;
 }
 \end{lstlisting}
     auto pointer_to_member_function = &A::f;
 }
 \end{lstlisting}
-\caption{Member function with reference-qualification example: source \mbox{fragment}}
+\caption{Reference- and rvalue-reference-qualification example: source \mbox{fragment}}
 \label{fig:memberfunctionrefqualexamplesourcefragment}
 \end{figure}
 
 \label{fig:memberfunctionrefqualexamplesourcefragment}
 \end{figure}
 
@@ -1486,7 +1486,7 @@ void g() {
          
 \end{alltt}
 \end{dwflisting}
          
 \end{alltt}
 \end{dwflisting}
-\caption{Member function with reference-qualification example: DWARF \mbox{description}}
+\caption{Reference- and rvalue-reference-qualification example: DWARF \mbox{description}}
 \label{fig:memberfunctionrefqualexampledwarfdescription}
 \end{figure}
 
 \label{fig:memberfunctionrefqualexampledwarfdescription}
 \end{figure}
 
@@ -2966,3 +2966,346 @@ int main ()
 \caption{C implicit pointer example \#2: DWARF description}
 \label{fig:cimplicitpointerexample2dwarf}
 \end{figure}
 \caption{C implicit pointer example \#2: DWARF description}
 \label{fig:cimplicitpointerexample2dwarf}
 \end{figure}
+
+\clearpage
+\section{Call Site Examples}
+\label{app:callsiteexamples}
+The following examples use a hypothetical machine which: 
+\begin{itemize}
+\item
+Passes the first argument in register 0, the second in register 1, and the third in register 2.
+\item
+Keeps the stack pointer is register 3.
+\item
+Has one call preserved register 4.
+\item
+Returns a function value in register 0.
+\end{itemize}
+
+\subsection{Call Site Example \#1 (C)}
+Consider the \addtoindex{C} source in Figure \referfol{fig:callsiteexample1source}.
+
+\begin{figure}[h]
+\begin{lstlisting}
+
+extern void fn1 (long int, long int, long int);
+
+long int
+fn2 (long int a, long int b, long int c) 
+{
+    long int q = 2 * a;
+    fn1 (5, 6, 7); 
+    return 0;
+}
+long int
+fn3 (long int x, long int (*fn4) (long int *))
+{
+    long int v, w, w2, z;
+    w = (*fn4) (&w2);
+    v = (*fn4) (&w2);
+    z = fn2 (1, v + 1, w);
+    {
+        int v1 = v + 4;
+        z += fn2 (w, v * 2, x);
+    }
+    return z;
+}
+\end{lstlisting}
+\caption{Call Site Example \#1: Source}
+\label{fig:callsiteexample1source}
+\end{figure}
+
+Possible generated code for this source is shown using a suggestive 
+pseudo-\linebreak[0]assembly notation in Figure \refersec{fig:callsiteexample1code}.
+
+\begin{figure}[ht]
+\begin{lstlisting}
+fn2:
+L1:
+    %reg2 = 7   ! Load the 3rd argument to fn1
+    %reg1 = 6   ! Load the 2nd argument to fn1
+    %reg0 = 5   ! Load the 1st argument to fn1
+L2:
+    call fn1
+    %reg0 = 0   ! Load the return value from the function
+    return
+L3:
+fn3:
+    ! Decrease stack pointer to reserve local stack frame
+    %reg3 = %reg3 - 32
+    [%reg3] = %reg4       ! Save the call preserved register to
+                          !   stack
+    [%reg3 + 8] = %reg0   ! Preserve the x argument value
+    [%reg3 + 16] = %reg1  ! Preserve the fn4 argument value
+    %reg0 = %reg3 + 24    ! Load address of w2 as argument
+    call %reg1            ! Call fn4 (indirect call)
+L6:
+    %reg2 = [%reg3 + 16]  ! Load the fn4 argument value
+    [%reg3 + 16] = %reg0  ! Save the result of the first call (w)
+    %reg0 = %reg3 + 24    ! Load address of w2 as argument
+    call %reg2            ! Call fn4 (indirect call)
+L7:
+    %reg4 = %reg0         ! Save the result of the second call (v) 
+                          !   into register.
+    %reg2 = [%reg3 + 16]  ! Load 3rd argument to fn2 (w)
+    %reg1 = %reg4 + 1     ! Compute 2nd argument to fn2 (v + 1)
+    %reg0 = 1             ! Load 1st argument to fn2
+    call fn2
+L4:
+    %reg2 = [%reg3 + 8]   ! Load the 3rd argument to fn2 (x)
+    [%reg3 + 8] = %reg0   ! Save the result of the 3rd call (z)
+    %reg0 = [%reg3 + 16]  ! Load the 1st argument to fn2 (w)
+    %reg1 = %reg4 + %reg4 ! Compute the 2nd argument to fn2 (v * 2)
+    call fn2
+L5:
+    %reg2 = [%reg3 + 8]   ! Load the value of z from the stack
+    %reg0 = %reg0 + %reg2 ! Add result from the 4th call to it
+L8:
+    %reg4 = [%reg3]       ! Restore original value of call preserved 
+                          !   register
+    %reg3 = %reg3 + 32    ! Leave stack frame
+    return
+\end{lstlisting}
+\caption{Call Site Example \#1: Code}
+\label{fig:callsiteexample1code}
+\end{figure}
+
+\clearpage
+The location list for variable \texttt{a} in function \texttt{fn2}
+might look like:
+%\begin{figure}[h]
+\begin{lstlisting}
+
+! Before the call to fn1 the argument a is live in the register 0
+!
+<L1, L2> DW_OP_reg0
+
+! Afterwards it is not, the call could have clobbered the register,
+! and it is not saved in the fn2 function stack frame either, but 
+! perhap scan be looked up in the caller
+!
+<L2, L3> DW_OP_entry_value 1 DW_OP_reg0 DW_OP_stack_value
+<0, 0>
+
+\end{lstlisting}
+%\end{figure}
+(where the notation \doublequote{\texttt{<m, n>}} specifies the address
+range over which the following location description applies).
+
+Similarly, the variable q in fn2 then might have location list:
+\begin{lstlisting}
+
+! Before the call to fn1 the value of q can be computed as two times
+! the value of register 0
+!
+<L1, L2> DW_OP_lit2 DW_OP_breg0 0 DW_OP_mul DW_OP_stack_value
+
+! Afterwards it can be computed from the original value of the first
+! parameter, multiplied by two
+!
+<L2, L3> DW_OP_lit2 DW_OP_entry_value 1 DW_OP_reg0 DW_OP_mul DW_OP_stack_value
+<0, 0>
+
+\end{lstlisting}
+
+Variables \texttt{b} and \texttt{c} each have a location list similar to 
+that for variable \texttt{a},
+except for a different label between the two ranges and they
+use \DWOPregone{} and \DWOPregtwo{}, respectively, instead of \DWOPregzero.
+
+
+The call sites for all the calls in function \texttt{fn3} are children of the
+\DWTAGsubprogram{} entry for \texttt{fn3} (or of its \DWTAGlexicalblock{} entry
+if there is any for the whole function). 
+This is shown in Figure \refersec{fig:callsiteexample1dwarf}.
+
+\begin{figure}[h]
+\figurepart{1}{2}
+\begin{dwflisting}
+\begin{alltt}
+    \DWTAGcallsite
+        \DWATcallreturnpc(L6) ! First indirect call to (*fn4) in fn3.
+        ! The address of the call is preserved across the call in memory at
+        ! stack pointer + 16 bytes.
+        \DWATcalltarget(\DWOPbregthree{} 16 \DWOPderef)
+        \DWTAGcallsiteparameter
+            \DWATlocation(\DWOPregzero)
+            ! Value of the first parameter is equal to stack pointer + 24 bytes.
+            \DWATcallvalue(\DWOPbregthree{} 24)
+    \DWTAGcallsite
+        \DWATcallreturnpc(L7) ! Second indirect call to (*fn4) in fn3.
+        ! The address of the call is not preserved across the call anywhere, but
+        ! could be perhaps looked up in fn3's caller.
+        \DWATcalltarget(\DWOPentryvalue{} 1 \DWOPregone)
+        \DWTAGcallsiteparameter
+            \DWATlocation(\DWOPregzero)
+            \DWATcallvalue(\DWOPbregthree{} 24)
+    \DWTAGcallsite
+        \DWATcallreturnpc(L4) ! 3rd call in fn3, direct call to fn2
+        \DWATcallorigin(reference to fn2 DW_TAG_subprogram)
+        \DWTAGcallsiteparameter
+            \DWATcallparameter(reference to formal parameter a in subprogram fn2)
+            \DWATlocation(\DWOPregzero)
+            ! First parameter to fn2 is constant 1
+            \DWATcallvalue(\DWOPlitone)
+        \DWTAGcallsiteparameter
+            \DWATcallparameter(reference to formal parameter b in subprogram fn2)
+            \DWATlocation(\DWOPregone)
+            ! Second parameter to fn2 can be computed as the value of the call
+            !   preserved register 4 in the fn3 function plus one
+            \DWATcallvalue(\DWOPbregfour{} 1)
+        \DWTAGcallsiteparameter
+            \DWATcallparameter(reference to formal parameter c in subprogram fn2)
+            \DWATlocation(\DWOPregtwo)
+            ! Third parameter's value is preserved in memory at fn3's stack pointer
+            !   plus 16 bytes
+            \DWATcallvalue(\DWOPbregthree{} 16 \DWOPderef)
+\end{alltt}
+\end{dwflisting}
+\caption{Call Site Example \#1: DWARF Encoding}
+\label{fig:callsiteexample1dwarf}
+\end{figure}
+
+\begin{figure}
+\figurepart{2}{2}
+\begin{dwflisting}
+\begin{alltt}
+\DWTAGlexicalblock
+    \DWATlowpc(L4)
+    \DWAThighpc(L8)
+    \DWTAGvariable
+        \DWATname("v1")
+        \DWATtype(reference to int)
+        ! Value of the v1 variable can be computed as value of register 4 plus 4
+        \DWATlocation(\DWOPbregfour{} 4 \DWOPstackvalue)
+    \DWTAGcallsite
+        \DWATcallreturnpc(L5) ! 4th call in fn3, direct call to fn2
+        \DWATcalltarget(reference to subprogram fn2)
+        \DWTAGcallsiteparameter
+            \DWATcallparameter(reference to formal parameter a in subprogram fn2)
+            \DWATlocation(\DWOPregzero)
+            ! Value of the 1st argument is preserved in memory at fn3's stack 
+            !   pointer + 16 bytes.
+            \DWATcallvalue(\DWOPbregthree{} 16 \DWOPderef)
+        \DWTAGcallsiteparameter
+            \DWATcallparameter(reference to formal parameter b in subprogram fn2)
+            \DWATlocation(\DWOPregone)
+            ! Value of the 2nd argument can be computed using the preserved 
+            !   register 4 multiplied by 2
+            \DWATcallvalue(\DWOPlittwo{} \DWOPregfour{} 0 \DWOPmul)
+        \DWTAGcallsiteparameter
+            \DWATcallparameter(reference to formal parameter c in subprogram fn2)
+            \DWATlocation(\DWOPregtwo)
+            ! Value of the 3rd argument is not preserved, but could be perhaps 
+            ! computed from the value passed fn3's caller.
+            \DWATcallvalue(\DWOPentryvalue{} 1 \DWOPregzero)
+\end{alltt}
+\end{dwflisting}
+\begin{center}
+\vspace{0.4cm}
+Figure~\ref{fig:callsiteexample1dwarf} Call Site Example \#1: DWARF Encoding \textit{(concluded)}
+\end{center}
+\end{figure}
+
+\clearpage
+\subsection{Call Site Example \#2 (Fortran)}
+Consider the \addtoindex{Fortran} source in 
+Figure \refersec{fig:callsiteexample2source}
+which is used to illustrate how Fortran's \doublequote{pass by reference}
+parameters can be handled.
+
+\begin{figure}[h]
+\begin{lstlisting}
+subroutine fn4 (n)
+    integer :: n, x
+    x = n
+    n = n / 2
+    call fn6
+end subroutine
+subroutine fn5 (n)
+    interface fn4
+        subroutine fn4 (n)
+            integer :: n
+        end subroutine
+    end interface fn4
+    integer :: n, x
+    call fn4 (n)
+    x = 5
+    call fn4 (x)
+end subroutine fn5
+\end{lstlisting}
+\caption{Call Site Example \#2: Source}
+\label{fig:callsiteexample2source}
+\end{figure}
+
+Possible generated code for this source is shown using a suggestive 
+pseudo-\linebreak[0]assembly notation in Figure \refersec{fig:callsiteexample2code}.
+\begin{figure}
+\begin{lstlisting}
+fn4:
+    %reg2 = [%reg0]   ! Load value of n (passed by reference)
+    %reg2 = %reg2 / 2 ! Divide by 2
+    [%reg0] = %reg2   ! Update value of n
+    call fn6          ! Call some other function
+    return
+
+fn5:
+    %reg3 = %reg3 - 8 ! Decrease stack pointer to create stack frame
+    call fn4          ! Call fn4 with the same argument by reference 
+                      !   as fn5 has been called with
+L9:
+    [%reg3] = 5       ! Pass value of 5 by reference to fn4
+    %reg0 = %reg3     ! Put address of the value 5 on the stack
+                      !   into 1st argument register
+    call fn4
+L10:
+    %reg3 = %reg3 + 8 ! Leave stack frame
+    return
+\end{lstlisting}
+\caption{Call Site Example \#2: Code}
+\label{fig:callsiteexample2code}
+\end{figure}
+
+The location description for variable \texttt{x} in function 
+\texttt{f}n4 might be:
+\begin{lstlisting}
+DW_OP_entry_value 4 DW_OP_breg0 0 DW_OP_deref_size 4 DW_OP_stack_value
+\end{lstlisting}
+
+The call sites in (just) function \texttt{fn5} might be as shown in 
+Figure \refersec{fig:callsiteexample2dwarf}.
+
+\begin{figure}
+\begin{dwflisting}
+\begin{alltt}
+\DWTAGcallsite
+    \DWATcallreturnpc(L9) ! First call to fn4
+    \DWATcallorigin(reference to subprogram fn4)
+    \DWTAGcallsiteparameter
+        \DWATcallparameter(reference to formal parameter n in subprogram fn4)
+        \DWATlocation(\DWOPregzero)
+        ! The value of register 0 at the time of the call can be perhaps 
+        !   looked up in fn5's caller
+        \DWATcallvalue(\DWOPentryvalue{} 1 \DWOPregzero)
+        ! DW_AT_call_data_location(DW_OP_push_object_address) ! left out, implicit
+        ! And the actual value of the parameter can be also perhaps looked up in
+        ! fn5's caller
+        \DWATcalldatavalue(\DWOPentryvalue{} 4 \DWOPbregzero{} 0 \DWOPderefsize 4)
+\DWTAGcallsite
+    \DWATcallreturnpc(L10) ! Second call to fn4
+    \DWATcallorigin(reference to subprogram fn4)
+    \DWTAGcallsiteparameter
+        \DWATcallparameter(reference to formal parameter n in subprogram fn4)
+        \DWATlocation(\DWOPregzero)
+        ! The value of register 0 at the time of the call is equal to the stack
+        ! pointer value in fn5
+        \DWATcallvalue(\DWOPbregthree{} 0)
+        ! DW_AT_call_data_location(DW_OP_push_object_address) ! left out, implicit
+        ! And the value passed by reference is constant 5
+        \DWATcalldatavalue(\DWOPlitfive)
+\end{alltt}
+\end{dwflisting}
+\caption{Call Site Example \#2: DWARF Encoding}
+\label{fig:callsiteexample2dwarf}
+\end{figure}
\ No newline at end of file
index 0f40da8..fdc4a86 100644 (file)
@@ -35,6 +35,8 @@ described in Chapters 3, 4 and 5.
 \DWTAGarraytype,
 \DWTAGatomictype,
 \DWTAGbasetype,
 \DWTAGarraytype,
 \DWTAGatomictype,
 \DWTAGbasetype,
+\DWTAGcallsite,
+\DWTAGcallsiteparameter,
 \DWTAGcatchblock,
 \DWTAGclasstype,
 \DWTAGcoarraytype,
 \DWTAGcatchblock,
 \DWTAGclasstype,
 \DWTAGcoarraytype,
@@ -214,15 +216,90 @@ to one of the classes shown in Table \refersec{tab:classesofattributevalue}.
 \DWATbytestrideTARG{} 
 &\livelinki{chap:DWATbytestridearrayelementstrideofarraytype}{Array element stride (of array type)}{array element stride (of array type)} \\
 &\livelinki{chap:DWATbytestridesubrangestridedimensionofarraytype}{Subrange stride (dimension of array type)}{subrange stride (dimension of array type)} \\
 \DWATbytestrideTARG{} 
 &\livelinki{chap:DWATbytestridearrayelementstrideofarraytype}{Array element stride (of array type)}{array element stride (of array type)} \\
 &\livelinki{chap:DWATbytestridesubrangestridedimensionofarraytype}{Subrange stride (dimension of array type)}{subrange stride (dimension of array type)} \\
-&\livelinki{chap:DWATbytestrideenumerationstridedimensionofarraytype}{Enumeration stride (dimension of array type)}{enumeration stride (dimension of array type)} \\
+&\livelinki{chap:DWATbytestrideenumerationstridedimensionofarraytype}
+           {Enumeration stride (dimension of array type)}
+           {enumeration stride (dimension of array type)} \\
+\DWATcallallcallsTARG{}
+&\livelinki{chap:DWATcallallcallsofasubprogram}
+           {All tail and normal calls in a subprogram are described by call site entries}
+           {all tail and normal calls in a subprogram are described by call site entries}
+           \index{call site!summary!all tail and normal calls are described} \\
+\DWATcallallsourcecallsTARG{}
+&\livelinki{chap:DWATcallallaourcecallsofa subprogram}
+           {All tail, normal and inlined calls in a subprogram are described by call site and inlined subprogram entries}
+           {all tail calls in a subprogram are described by call site and inlined subprogram entries}
+           \index{call site!summary!all tail, normal and inlined calls are described} \\
+\DWATcallalltailcallsTARG{}
+&\livelinki{chap:DWATcallalltailcallsofasubprogram}
+           {All tail calls in a subprogram are described by call site entries}
+           {all tail calls in a subprogram are described by call site entries}
+           \index{call site!summary!all tail calls are described} \\
 \DWATcallcolumnTARG{} 
 \DWATcallcolumnTARG{} 
-&\livelinki{chap:DWATcallcolumncolumnpositionofinlinedsubroutinecall}{Column position of inlined subroutine call}{column position of inlined subroutine call}\\
+&\livelinki{chap:DWATcallcolumncolumnpositionofinlinedsubroutinecall}
+           {Column position of inlined subroutine call}
+           {column position of inlined subroutine call} \\
+\DWATcalldatalocationTARG{}
+&\livelinki{chap:DWATcalldatalocationofcallsite}
+           {Address of the value pointed to by an argument passed in a call}
+           {address of the value pointed to by an argument passed in a call}
+           \index{call site!address of the value pointed to by an argument} \\
+\DWATcalldatavalueTARG{}
+&\livelinki{chap:DWATcalldatavalueofcallsite}
+           {Value pointed to by an argument passed in a call}
+           {value pointed to by an argument passed in a call}
+           \index{call site!value pointed to by an argument} \\
 \DWATcallfileTARG
 \DWATcallfileTARG
-&\livelinki{chap:DWATcallfilefilecontaininginlinedsubroutinecall}{File containing inlined subroutine call}{file containing inlined subroutine call} \\
+&\livelinki{chap:DWATcallfilefilecontaininginlinedsubroutinecall}
+           {File containing inlined subroutine call}
+           {file containing inlined subroutine call} \\
 \DWATcalllineTARG{} 
 \DWATcalllineTARG{} 
-&\livelinki{chap:DWATcalllinelinenumberofinlinedsubroutinecall}{Line number of inlined subroutine call}{line number of inlined subroutine call} \\
+&\livelinki{chap:DWATcalllinelinenumberofinlinedsubroutinecall}
+           {Line number of inlined subroutine call}
+           {line number of inlined subroutine call} \\
 \DWATcallingconventionTARG{} 
 \DWATcallingconventionTARG{} 
-&\livelinki{chap:DWATcallingconventionsubprogramcallingconvention}{Subprogram calling convention}{subprogram calling convention} \\
+&\livelinki{chap:DWATcallingconventionsubprogramcallingconvention}
+           {Subprogram calling convention}
+           {subprogram calling convention} \\
+\DWATcalloriginTARG{}
+&\livelinki{chap:DWATcalloriginofcallsite}
+           {Subprogram called in a call}
+           {subprogram called in a call}
+           \index{call site!subprogram called} \\
+\DWATcallparameterTARG{}
+&\livelinki{chap:DWATcallparameterofcallsite}
+           {Parameter entry in a call}
+           {parameter entry in a call}
+           \index{call site!parameter entry} \\
+\DWATcallpcTARG{}
+&\livelinki{chap:DWATcallpcofcallsite}
+           {Address of the call instruction in a call}
+           {address of the call instruction in a call}
+           \index{call site!address of the call instruction} \\
+\DWATcallreturnpcTARG{}
+&\livelinki{chap:DWATcallreturnpcofcallsite}
+           {Return address from a call}
+           {return address from a call}
+           \index{call site!return address} \\
+\DWATcalltailcallTARG{}
+&\livelinki{chap:DWATcalltailcallofcallsite}
+           {Call is a tail call}
+           {call is a tail call}
+           \index{call site!tail call} \\
+\DWATcalltargetTARG{}
+&\livelinki{chap:DWATcalltargetofcallsite}
+           {Address of called routine in a call}
+           {address of called routine in a call}
+           \index{call site!address of called routine} \\
+\DWATcalltargetclobberedTARG{}
+&\livelinki{chap:DWATcalltargetclobberedofcallsite}
+           {Address of called routine, which may be clobbered, in a call}
+           {address of called routine, which may be clobbered, in a call}
+           \index{call site!address of called routine, which may be clobbered} \\
+\DWATcallvalueTARG{}
+&\livelinki{chap:DWATcallvalueofcallsite}
+           {Argument value passed in a call}
+           {argument value passed in a call}
+           \index{call site!argument value passed} \\
 \DWATcommonreferenceTARG
 &\livelinki{chap:commonreferencecommonblockusage}{Common block usage}{common block usage} \\
 \DWATcompdirTARG
 \DWATcommonreferenceTARG
 &\livelinki{chap:commonreferencecommonblockusage}{Common block usage}{common block usage} \\
 \DWATcompdirTARG
@@ -723,24 +800,25 @@ The single operand of a \DWOPconstnsNAME{} operation provides a 1,
 
 \itembfnl{\DWOPconstuTARG}
 The single operand of the \DWOPconstuNAME{} operation provides
 
 \itembfnl{\DWOPconstuTARG}
 The single operand of the \DWOPconstuNAME{} operation provides
-an unsigned LEB128 integer constant.
+an unsigned LEB128\addtoindexx{LEB128!unsigned} integer constant.
 
 \itembfnl{\DWOPconstsTARG}
 The single operand of the \DWOPconstsNAME{} operation provides
 
 \itembfnl{\DWOPconstsTARG}
 The single operand of the \DWOPconstsNAME{} operation provides
-a signed LEB128 integer constant.
+a signed LEB128\addtoindexx{LEB128!unsigned} integer constant.
 
 \needlines{4}
 \itembfnl{\DWOPaddrxTARG}
 The \DWOPaddrxNAME{} operation has a single operand that
 
 \needlines{4}
 \itembfnl{\DWOPaddrxTARG}
 The \DWOPaddrxNAME{} operation has a single operand that
-encodes an unsigned LEB128 value, which is a zero-based
-index into the \dotdebugaddr{} section, where a machine
-address is stored.
+encodes an unsigned LEB128\addtoindexx{LEB128!unsigned} value, 
+which is a zero-based index into the \dotdebugaddr{} section, 
+where a machine address is stored.
 This index is relative to the value of the 
 \DWATaddrbase{} attribute of the associated compilation unit.
 
 \itembfnl{\DWOPconstxTARG}
 The \DWOPconstxNAME{} operation has a single operand that
 This index is relative to the value of the 
 \DWATaddrbase{} attribute of the associated compilation unit.
 
 \itembfnl{\DWOPconstxTARG}
 The \DWOPconstxNAME{} operation has a single operand that
-encodes an unsigned LEB128 value, which is a zero-based
+encodes an unsigned LEB128\addtoindexx{LEB128!unsigned} value, 
+which is a zero-based
 index into the \dotdebugaddr{} section, where a constant, the
 size of a machine address, is stored.
 This index is relative to the value of the 
 index into the \dotdebugaddr{} section, where a constant, the
 size of a machine address, is stored.
 This index is relative to the value of the 
@@ -762,7 +840,8 @@ the result of adding the contents of a register to a given
 signed offset.
 \begin{enumerate}[1. ]
 \itembfnl{\DWOPfbregTARG}
 signed offset.
 \begin{enumerate}[1. ]
 \itembfnl{\DWOPfbregTARG}
-The \DWOPfbregTARG{} operation provides a signed LEB128 offset
+The \DWOPfbregTARG{} 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
 is typically a \doublequote{stack pointer} register plus or minus
 from the address specified by the location description in the
 \DWATframebase{} attribute of the current function. (This
 is typically a \doublequote{stack pointer} register plus or minus
@@ -773,13 +852,13 @@ in the stack pointer as the PC changes.)
 \itembfnl{\DWOPbregzeroTARG, \DWOPbregoneTARG, \dots, \DWOPbregthirtyoneTARG}
 The single operand of the \DWOPbregnTARG{} 
 operations provides
 \itembfnl{\DWOPbregzeroTARG, \DWOPbregoneTARG, \dots, \DWOPbregthirtyoneTARG}
 The single operand of the \DWOPbregnTARG{} 
 operations provides
-a signed LEB128 offset from
+a signed LEB128\addtoindexx{LEB128!signed} offset from
 the specified register.
 
 \itembfnl{\DWOPbregxTARG{} }
 The \DWOPbregxINDX{} operation has two operands: a register
 the specified register.
 
 \itembfnl{\DWOPbregxTARG{} }
 The \DWOPbregxINDX{} operation has two operands: a register
-which is specified by an unsigned LEB128 number, followed by
-a signed LEB128 offset.
+which is specified by an unsigned LEB128\addtoindexx{LEB128!unsigned}
+number, followed by a signed LEB128\addtoindexx{LEB128!signed} offset.
 
 \end{enumerate}
 
 
 \end{enumerate}
 
@@ -1012,8 +1091,8 @@ adds them together, and pushes the result.
 \needlines{6}
 \itembfnl{\DWOPplusuconstTARG}
 The \DWOPplusuconstTARG{} operation pops the top stack entry,
 \needlines{6}
 \itembfnl{\DWOPplusuconstTARG}
 The \DWOPplusuconstTARG{} operation pops the top stack entry,
-adds it to the unsigned LEB128 constant operand and pushes
-the result.
+adds it to the unsigned LEB128\addtoindexx{LEB128!unsigned}
+constant operand and pushes the result.
 
 \textit{This operation is supplied specifically to be
 able to encode more field offsets in two bytes than can be
 
 \textit{This operation is supplied specifically to be
 able to encode more field offsets in two bytes than can be
@@ -1144,11 +1223,44 @@ by prior agreement between the calling and called expressions.
 \subsubsection{Special Operations}
 There 
 \addtoindexx{DWARF expression!special operations}
 \subsubsection{Special Operations}
 There 
 \addtoindexx{DWARF expression!special operations}
-is one special operation currently defined:
+are these special operations currently defined:
 \begin{enumerate}[1. ]
 \begin{enumerate}[1. ]
-\itembfnl{\DWOPnopTARG}
+\itembfnl{\DWOPnopNAME}
 The \DWOPnopTARG{} operation is a place holder. It has no effect
 on the location stack or any of its values.
 The \DWOPnopTARG{} operation is a place holder. It has no effect
 on the location stack or any of its values.
+
+\itembfnl{\DWOPentryvalueNAME}
+The \DWOPentryvalueTARG{} operation pushes a value that had a known location
+upon entering the current subprogram.  It uses two operands: an 
+unsigned LEB128\addtoindexx{LEB128!unsigned} length, followed by 
+a block containing a DWARF expression or
+a simple register location description.  The length gives the length
+in bytes of the block.  If the block contains a register location
+description, \DWOPentryvalueNAME{} pushes the value that register had upon
+entering the current subprogram.  If the block contains a DWARF expression,
+the DWARF expression is evaluated as if it has been evaluated upon entering
+the current subprogram.  The DWARF expression should not assume any values
+being present on the DWARF stack initially and should result in exactly one
+value being pushed on the DWARF stack when completed.  That value is the value
+being pushed by the \DWOPentryvalueNAME{} operation.  
+
+\DWOPpushobjectaddress{} is not meaningful inside of this DWARF operation.
+
+\textit{The \DWOPentryvalueNAME{} operation can be used by consumers if they are able
+to find the call site in the caller function, unwind to it and the corresponding
+\DWTAGcallsiteparameter{} entry has \DWATcallvalue{} or
+\DWATcalldatavalue{} attributes that can be evaluated to find out the
+value a function parameter had on the first instruction in the function.
+Or non-interactive consumers which know what variables will need to be
+inspected ahead of running the debugged program could put breakpoint
+on the first instruction in functions where there is no other way to find
+some variable's value, but evaluating \DWOPentryvalueNAME{} operation.  The
+consumer can collect there the value of registers or memory referenced in
+\DWOPentryvalueNAME{} operations, then continue to breakpoints where the values
+of variables or parameters need to be inspected and use there the remembered
+register or memory values during \DWOPentryvalueNAME{} evaluation.
+}
+
 \end{enumerate}
 
 \subsection{Example Stack Operations}
 \end{enumerate}
 
 \subsection{Example Stack Operations}
@@ -1347,7 +1459,8 @@ addressed is in register \textit{n}.
 
 \needlines{4}
 \itembfnl{\DWOPregxTARG}
 
 \needlines{4}
 \itembfnl{\DWOPregxTARG}
-The \DWOPregxTARG{} operation has a single unsigned LEB128 literal
+The \DWOPregxTARG{} operation has a single 
+unsigned LEB128\addtoindexx{LEB128!unsigned} literal
 operand that encodes the name of a register.  
 
 \end{enumerate}
 operand that encodes the name of a register.  
 
 \end{enumerate}
@@ -1376,7 +1489,8 @@ or is computed from other locations and values in the program.
 \itembfnl{\DWOPimplicitvalueTARG}
 The \DWOPimplicitvalueTARG{} 
 operation specifies an immediate value
 \itembfnl{\DWOPimplicitvalueTARG}
 The \DWOPimplicitvalueTARG{} 
 operation specifies an immediate value
-using two operands: an unsigned LEB128 length, followed by
+using two operands: an unsigned LEB128\addtoindexx{LEB128!unsigned}
+length, followed by
 %FIXME: should this block be a reference? To what?
 a \nolink{block} representing the value in the memory representation
 of the target machine. The length operand gives the length
 %FIXME: should this block be a reference? To what?
 a \nolink{block} representing the value in the memory representation
 of the target machine. The length operand gives the length
@@ -1411,7 +1525,8 @@ The first operand is a 4-byte unsigned value in the 32-bit
 DWARF format, or an 8-byte unsigned value in the 64-bit 
 DWARF format (see Section 
 \refersec{datarep:32bitand64bitdwarfformats}).
 DWARF format, or an 8-byte unsigned value in the 64-bit 
 DWARF format (see Section 
 \refersec{datarep:32bitand64bitdwarfformats}).
-The second operand is a \addtoindex{signed LEB128} number.
+The second operand is a 
+signed LEB128\addtoindexx{LEB128!signed} number.
 
 The first operand is used as the offset of a debugging
 information entry in a \dotdebuginfo{} section, which may be
 
 The first operand is used as the offset of a debugging
 information entry in a \dotdebuginfo{} section, which may be
@@ -1473,7 +1588,8 @@ of the resultant value is contained.
 \itembfnl{\DWOPpieceTARG}
 The \DWOPpieceTARG{} operation takes a 
 single operand, which is an
 \itembfnl{\DWOPpieceTARG}
 The \DWOPpieceTARG{} operation takes a 
 single operand, which is an
-unsigned LEB128 number.  The number describes the size in bytes
+unsigned LEB128\addtoindexx{LEB128!unsigned} number.  
+The number describes the size in bytes
 of the piece of the object referenced by the preceding simple
 location description. If the piece is located in a register,
 but does not occupy the entire register, the placement of
 of the piece of the object referenced by the preceding simple
 location description. If the piece is located in a register,
 but does not occupy the entire register, the placement of
@@ -1488,8 +1604,10 @@ refers to. }
 \itembfnl{\DWOPbitpieceTARG}
 The \DWOPbitpieceTARG{} 
 operation takes two operands. The first
 \itembfnl{\DWOPbitpieceTARG}
 The \DWOPbitpieceTARG{} 
 operation takes two operands. The first
-is an unsigned LEB128 number that gives the size in bits
-of the piece. The second is an unsigned LEB128 number that
+is an unsigned LEB128\addtoindexx{LEB128!unsigned} 
+number that gives the size in bits
+of the piece. The second is an 
+unsigned LEB128\addtoindexx{LEB128!unsigned} number that
 gives the offset in bits from the location defined by the
 preceding DWARF location description.  
 
 gives the offset in bits from the location defined by the
 preceding DWARF location description.  
 
@@ -1538,6 +1656,7 @@ The value of a static variable is at machine address 0x80d0045c.
 Add 44 to the value in register 11 to get the address of an automatic
 variable instance.
 
 Add 44 to the value in register 11 to get the address of an automatic
 variable instance.
 
+\needlines{4}
 \descriptionitemnl{\DWOPfbreg{} -50}
 Given a \DWATframebase{} value of
 \doublequote{\DWOPbregthirtyone{} 64,} this example
 \descriptionitemnl{\DWOPfbreg{} -50}
 Given a \DWATframebase{} value of
 \doublequote{\DWOPbregthirtyone{} 64,} this example
@@ -1549,6 +1668,7 @@ stack pointer (register 31).
 A call-by-reference parameter whose address is in the word 32 bytes
 from where register 54 points.
 
 A call-by-reference parameter whose address is in the word 32 bytes
 from where register 54 points.
 
+\needlines{4}
 \descriptionitemnl{\DWOPplusuconst{} 4}
 A structure member is four bytes from the start of the structure
 instance. The base address is assumed to be already on the stack.
 \descriptionitemnl{\DWOPplusuconst{} 4}
 A structure member is four bytes from the start of the structure
 instance. The base address is assumed to be already on the stack.
@@ -1558,7 +1678,7 @@ A variable whose first four bytes reside in register 3 and whose next
 two bytes reside in register 10.
 
 \descriptionitemnl{\DWOPregzero{} \DWOPpiece{} 4 \DWOPpiece{} 4 \DWOPfbreg{} -12 \DWOPpiece{} 4}
 two bytes reside in register 10.
 
 \descriptionitemnl{\DWOPregzero{} \DWOPpiece{} 4 \DWOPpiece{} 4 \DWOPfbreg{} -12 \DWOPpiece{} 4}
-A twelve byte value whose first four bytes reside in register zero,
+\vspace{-2\parsep}A twelve byte value whose first four bytes reside in register zero,
 whose middle four bytes are unavailable (perhaps due to optimization),
 and whose last four bytes are in memory, 12 bytes before the frame
 base.
 whose middle four bytes are unavailable (perhaps due to optimization),
 and whose last four bytes are in memory, 12 bytes before the frame
 base.
@@ -1567,14 +1687,36 @@ base.
 Add the contents of r1 and r2 to compute a value. This value is the
 \doublequote{contents} of an otherwise anonymous location.
 
 Add the contents of r1 and r2 to compute a value. This value is the
 \doublequote{contents} of an otherwise anonymous location.
 
-\needlines{6}
-\descriptionitemnl{\DWOPlitone{} \DWOPstackvalue{} \DWOPpiece{} 4 }
-\vspace{-0.1\parsep}
-\descriptionitemnl{\DWOPbregthree 0 \DWOPbregfour 0 \DWOPplus{} \DWOPstackvalue{} \DWOPpiece{} 4}
+
+\descriptionitemnl{\DWOPlitone{} \DWOPstackvalue{} \DWOPpiece{} 4 \DWOPbregthree{} 0 \DWOPbregfour{} 0}
+\vspace{-2\parsep}\descriptionitemnl{
+\hspace{0.5cm}\DWOPplus{} \DWOPstackvalue{} \DWOPpiece{} 4 \DWOPpiece{} 4}
 The object value is found in an anonymous (virtual) location whose
 value consists of two parts, given in memory address order: the 4 byte
 value 1 followed by the four byte value computed from the sum of the
 contents of r3 and r4.
 The object value is found in an anonymous (virtual) location whose
 value consists of two parts, given in memory address order: the 4 byte
 value 1 followed by the four byte value computed from the sum of the
 contents of r3 and r4.
+
+\descriptionitemnl{\DWOPentryvalue{} 1 \DWOPregone{} \DWOPstackvalue }
+The value register 1 had upon entering the current subprogram.
+
+\descriptionitemnl{\DWOPentryvalue{} 2 \DWOPbregone{} 0 \DWOPstackvalue }
+The value register 1 had upon entering the current subprogram (same as the previous example).
+%Both of these location descriptions evaluate to the value register 1 had upon
+%entering the current subprogram.
+
+%FIXME: The following gets an undefined control sequence error for reasons unknown... 
+%\descriptionitemnl{\DWOPentryvalue{} 1 \DWOPregthirtyone{} \DWOPregone{} \DWOPadd{} \DWOPstackvalue }
+%The value register 31 had upon entering the current subprogram
+%plus the value register 1 currently has.
+
+\descriptionitemnl{\DWOPentryvalue{} 3 \DWOPbregfour{} 16 \DWOPderef{} \DWOPstackvalue }
+%FIXME: similar undefined as just above
+%\descriptionitemnl{\DWOPentryvalue{} 6 \DWOPentryvalue{} 1 \DWOPregfour{} \DWOPplusuconst{} 16 \DWOPderef{} \DWOPstackvalue }
+%These two location expressions do the same thing, p
+Push the value of the
+memory location with the size of an address pointed to by the value of
+register 4 upon entering the current subprogram and add 16.
+
 \end{description}
 
 
 \end{description}
 
 
@@ -1764,7 +1906,8 @@ This entry indicates the end of a location list, and
 contains no further data.
 
 \itembfnl{\DWLLEbaseaddressselectionentryTARG}
 contains no further data.
 
 \itembfnl{\DWLLEbaseaddressselectionentryTARG}
-This entry contains an unsigned LEB128 value immediately
+This entry contains an 
+unsigned LEB128\addtoindexx{LEB128!unsigned} value immediately
 following the type code. This value is the index of an
 address in the \dotdebugaddr{} section, which is then used as
 the base address when interpreting offsets in subsequent
 following the type code. This value is the index of an
 address in the \dotdebugaddr{} section, which is then used as
 the base address when interpreting offsets in subsequent
@@ -1773,8 +1916,8 @@ This index is relative to the value of the
 \DWATaddrbase{} attribute of the associated compilation unit.
 
 \itembfnl{\DWLLEstartendentryTARG}
 \DWATaddrbase{} attribute of the associated compilation unit.
 
 \itembfnl{\DWLLEstartendentryTARG}
-This entry contains two unsigned LEB128 values
-immediately following the type code. These values are the
+This entry contains two unsigned LEB128\addtoindexx{LEB128!unsigned}
+values immediately following the type code. These values are the
 indices of two addresses in the \dotdebugaddr{} section.
 These indices are relative to the value of the 
 \DWATaddrbase{} attribute of the associated compilation unit.
 indices of two addresses in the \dotdebugaddr{} section.
 These indices are relative to the value of the 
 \DWATaddrbase{} attribute of the associated compilation unit.
@@ -1786,7 +1929,8 @@ compilation unit base address. A single location
 description follows the fields that define the address range.
 
 \itembfnl{\DWLLEstartlengthentryTARG}
 description follows the fields that define the address range.
 
 \itembfnl{\DWLLEstartlengthentryTARG}
-This entry contains one unsigned LEB128 value and a 4-byte
+This entry contains one unsigned LEB128\addtoindexx{LEB128!unsigned}
+value and a 4-byte
 unsigned value immediately following the type code. The
 first value is the index of an address in the \dotdebugaddr{}
 section, which marks the beginning of the address range
 unsigned value immediately following the type code. The
 first value is the index of an address in the \dotdebugaddr{}
 section, which marks the beginning of the address range
index 92398ec..cd55274 100644 (file)
@@ -140,34 +140,38 @@ in Table \refersec{tab:languagenames}.
 \begin{tabular}{l|l}
 \hline
 Language name & Meaning\\ \hline
 \begin{tabular}{l|l}
 \hline
 Language name & Meaning\\ \hline
-\DWLANGAdaeightythreeTARG{} \dag & ISO \addtoindex{Ada}:1983 \addtoindexx{Ada} \\
-\DWLANGAdaninetyfiveTARG{} \dag & ISO Ada:1995 \addtoindexx{Ada} \\
-\DWLANGCTARG & Non-standardized C, such as K\&R \\
-\DWLANGCeightynineTARG & ISO C:1989 \\
-\DWLANGCninetynineTARG & ISO \addtoindex{C}:1999 \\
-\DWLANGCplusplusTARG & ISO \addtoindex{C++}:1998 \\
-\DWLANGCpluspluszerothreeTARG & ISO \addtoindex{C++}:2003 \\
-\DWLANGCpluspluselevenTARG & ISO \addtoindex{C++}:2011 \\
-\DWLANGCobolseventyfourTARG & ISO \addtoindex{COBOL}:1974 \\
-\DWLANGCoboleightyfiveTARG & ISO \addtoindex{COBOL}:1985 \\
+\addtoindexx{ISO-defined language names}
+\DWLANGAdaeightythreeTARG{} \dag & ISO Ada:1983 \addtoindexx{Ada:1983 (ISO)} \\
+\DWLANGAdaninetyfiveTARG{}  \dag & ISO Ada:1995 \addtoindexx{Ada:1995 (ISO)} \\
+\DWLANGCTARG & Non-standardized C, such as K\&R \addtoindexx{C!non-standard}\\
+\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)} \\
+\DWLANGCobolseventyfourTARG & ISO COBOL:1974 \addtoindexx{COBOL:1974 (ISO)} \\
+\DWLANGCoboleightyfiveTARG  & ISO COBOL:1985 \addtoindexx{COBOL:1985 (ISO)} \\
 \DWLANGDTARG{} \dag & D \addtoindexx{D language} \\
 \DWLANGDTARG{} \dag & D \addtoindexx{D language} \\
-\DWLANGFortranseventysevenTARG &ISO \addtoindex{FORTRAN} 77\\
-\DWLANGFortranninetyTARG & ISO \addtoindex{Fortran 90}\\
-\DWLANGFortranninetyfiveTARG & ISO \addtoindex{Fortran 95}\\
-\DWLANGGoTARG{} \dag & \addtoindex{Go}\\
-\DWLANGHaskellTARG{} \dag & \addtoindex{Haskell}\\
+\DWLANGFortranseventysevenTARG & ISO FORTRAN:1977 \addtoindexx{FORTRAN:1977 (ISO)} \\
+\DWLANGFortranninetyTARG       & ISO Fortran:1990 \addtoindexx{Fortran:1990 (ISO)} \\
+\DWLANGFortranninetyfiveTARG   & ISO Fortran:1995 \addtoindexx{Fortran:1995 (ISO)} \\
+\DWLANGGoTARG{} \dag & \addtoindex{Go} \\
+\DWLANGHaskellTARG{} \dag & \addtoindex{Haskell} \\
 \DWLANGJavaTARG{} & \addtoindex{Java}\\
 \DWLANGJavaTARG{} & \addtoindex{Java}\\
-\DWLANGModulatwoTARG & ISO Modula\dash 2:1996 \addtoindexx{Modula-2}\\
-\DWLANGModulathreeTARG & \addtoindex{Modula-3}\\
-\DWLANGObjCTARG{} & \addtoindex{Objective C}\\
-\DWLANGObjCplusplusTARG{} & \addtoindex{Objective C++}\\
-\DWLANGOCamlTARG{} \dag & \addtoindex{OCaml}\index{Objective Caml|see{OCaml}}\\
-\DWLANGOpenCLTARG{} \dag & \addtoindex{OpenCL}\\
-\DWLANGPascaleightythreeTARG & ISO \addtoindex{Pascal}:1983\\
-\DWLANGPLITARG{} \dag & ANSI \addtoindex{PL/I}:1976\\
-\DWLANGPythonTARG{} \dag & \addtoindex{Python}\\
+\DWLANGModulatwoTARG   & ISO Modula\dash 2:1996 \addtoindexx{Modula-2:1996 (ISO)} \\
+\DWLANGModulathreeTARG & \addtoindex{Modula-3} \\
+\DWLANGObjCTARG{}         & \addtoindex{Objective C} \\
+\DWLANGObjCplusplusTARG{} & \addtoindex{Objective C++} \\
+\DWLANGOCamlTARG{} \dag  & \addtoindex{OCaml}\index{Objective Caml|see{OCaml}} \\
+\DWLANGOpenCLTARG{} \dag & \addtoindex{OpenCL} \\
+\DWLANGPascaleightythreeTARG & ISO Pascal:1983 \addtoindexx{Pascal:1983 (ISO)} \\
+\DWLANGPLITARG{} \dag & ANSI PL/I:1976 \addtoindexx{PL/I:1976 (ANSI)} \\
+\DWLANGPythonTARG{} \dag & \addtoindex{Python} \\
 \DWLANGRustTARG{} \dag & \addtoindex{Rust} \\
 \DWLANGRustTARG{} \dag & \addtoindex{Rust} \\
-\DWLANGUPCTARG{} & \addtoindex{Unified Parallel C}\addtoindexx{UPC}\\ \hline
+\DWLANGUPCTARG{} & UPC (Unified Parallel C) \addtoindexx{UPC}  
+                         \index{Unified Parallel C|see{UPC}} \\ 
+\hline
 \dag \ \ \textit{Support for these languages is limited.}& \\
 \end{tabular}
 \end{table}
 \dag \ \ \textit{Support for these languages is limited.}& \\
 \end{tabular}
 \end{table}
@@ -1096,7 +1100,37 @@ The attribute indicates whether the subroutine
 or entry point was declared with the \doublequote{recursive} keyword
 or property.
 
 or entry point was declared with the \doublequote{recursive} keyword
 or property.
 
-
+\subsubsection{Call Site-Related Attributes}
+A subroutine entry may have \DWATcallalltailcalls, \DWATcallallcalls{} 
+and/or \DWATcallallsourcecalls{} attributes, each of which is a 
+\livelink{chap:classflag}{flag}.
+These flags indicate the completeness of the call site information 
+within the subprogram.
+
+The \DWATcallalltailcalls{} attribute indicates that every tail call 
+that occurs in the code for the subprogram is described by a 
+\DWTAGcallsite{} entry. 
+(There may or may not be other non-tail calls to some of the same 
+target subprograms.)
+
+The \DWATcallallcalls{} attribute indicates that every non-inlined call
+(either a tail call or a normal call) that occurs in the code for the subprogram
+is described by a \DWTAGcallsite{} entry.
+
+The \DWATcallallsourcecalls{} attribute indicates that every call that occurs in the
+code for the subprogram, including every call inlined into it, is described by either a 
+\DWTAGcallsite{} entry or a \DWTAGinlinedsubroutine{} entry; further, any call
+that is optimized out is nonetheless also described using a \DWTAGcallsite{} entry 
+that has neither a \DWATcallpc{} nor \DWATcallreturnpc{} attribute.
+
+\textit{The \DWATcallallsourcecalls{} attribute is intended for debugging 
+information format consumers that analyse call graphs.}
+
+If the value of the \DWATcallallsourcecalls{} attribute is true then the values of the
+\DWATcallallcalls{} and \DWATcallallcalls{} 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.
 
 \subsection{Subroutine and Entry Point Return Types}
 \label{chap:subroutineandentrypointreturntypes}
 
 \subsection{Subroutine and Entry Point Return Types}
 \label{chap:subroutineandentrypointreturntypes}
@@ -1387,6 +1421,7 @@ artificially by the compiler for this instantiation.
 
 \needlines{8}
 \subsection{Inlinable and Inlined Subroutines}
 
 \needlines{8}
 \subsection{Inlinable and Inlined Subroutines}
+\label{chap:inlinedsubroutines}
 A declaration or a definition of an inlinable subroutine
 is represented by a debugging information entry with the
 tag 
 A declaration or a definition of an inlinable subroutine
 is represented by a debugging information entry with the
 tag 
@@ -1901,6 +1936,170 @@ hide the compiler generated subprogram from the user. }
 to repeatedly step until control arrives in a new subroutine
 which can be assumed to be the target subroutine. }
 
 to repeatedly step until control arrives in a new subroutine
 which can be assumed to be the target subroutine. }
 
+\subsection{Call Site Entries}
+\label{chap:callsiteentries}
+\textit{
+A call site entry provides a way to represent the static or dynamic 
+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,
+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 in the call site information sometimes
+find how to 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
+debugging information entry representing the scope within which the
+call is present in the source program.
+
+\textit{A scope entry (for example, for a lexical block) that would not 
+otherwise be present in the debugging information of a subroutine
+need not be introduced solely to represent the immediately containing scope
+of a call. The call site entry is owned by the innermost scope entry that
+is present.}
+
+A source call can be compiled into different types of machine code:
+\begin{itemize}
+\item
+A \textit{normal call} uses a call-like instruction which transfers control to the start
+of some subprogram and leaves the call site location address somewhere where
+unwind information can find it.  
+\item
+A \textit{tail call} uses a jump-like instruction which
+transfers control to the start of some subprogram, but the call site location
+address is not preserved (and thus not available using the unwind information).  
+\item
+A \textit{tail recursion call} is a call
+to the current subroutine which is compiled as a loop into the middle of the
+current subroutine.
+\item
+An \textit{inline (or inlined) call} is a call to an inlined subprogram,
+where at least one instruction has the location of the inlined subprogram
+or any of its blocks or inlined subprograms. 
+\end{itemize}
+
+There are also different types of \doublequote{optimized out} calls:
+\begin{itemize}
+\item
+An \textit{optimized out (normal) call} is a call that is in unreachable code that 
+has not been emitted (such as, for example, the call to \texttt{foo} in 
+\texttt{if (0) foo();}).  
+\item
+An \textit{optimized out inline call}
+is a call to an inlined subprogram which either did not expand to any instructions
+or only parts of instructions belong to it and for debug information purposes those
+instructions are given a location in the caller.
+\end{itemize}
+
+\DWTAGcallsite{} entries describe normal and tail calls but not tail recursion calls,
+while \DWTAGinlinedsubroutine{} entries describe inlined calls 
+(see Section \refersec{chap:inlinedsubroutines}).
+
+The call site entry has a 
+\DWATcallreturnpcTARG{} \addtoindexi{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 
+call frame information in the called subprogram 
+(see Section \refersec{datarep:callframeinformation}).
+
+\textit{On many architectures the return address is the address immediately following the
+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 
+\DWATcallpcTARG{} \addtoindexi{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 
+\DWATcalltailcallTARG{} \addtoindexi{attribute}{call tail call attribute},
+which is a \CLASSflag.
+
+The call site entry may have a 
+\DWATcalloriginTARG{} \addtoindex{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
+information entry.  For indirect calls it may be a reference to a
+\DWTAGvariable{}, \DWTAGformalparameter{} or \DWTAGmember{} entry representing
+the subroutine pointer that is called.
+
+The call site may have a 
+\DWATcalltargetTARG{} \addtoindexi{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
+address of the subprogram that will be called.  The DWARF expression should
+not use register or memory locations that might be clobbered by the call.
+
+The call site entry may have a 
+\DWATcalltargetclobberedTARG{} \addtoindexi{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 \DWATtype{} attribute referencing 
+a debugging information entry for the type of the called function.  
+When \DWATcallorigin{} is present, \DWATtype{} is usually omitted.
+
+The call site entry may have \DWATcallfile{}, \DWATcallline{} and
+\DWATcallcolumn{} attributes, each of whose value is an integer constant.
+These attributes represent the source file, source line number, and source
+column number, respectively, of the first character of the call statement or
+expression.  The call file, call line, and call column attributes are
+interpreted in the same way as the declaration file, declaration
+line, and declaration column attributes, respectively 
+(see Section \refersec{chap:declarationcoordinates}).
+
+\textit{The call file, call line and call column coordinates do not describe the
+coordinates of the subroutine declaration that was inlined, rather they describe
+the coordinates of the call.}
+
+The call site entry may own \DWTAGcallsiteparameterTARG{} debugging information
+entries\index{call site parameter entry} 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
+in (usually either some register, or a memory location expressible as the
+contents of the stack register plus some offset).
+
+Each \DWTAGcallsiteparameterTARG{} entry may have a 
+\DWATcallvalue{} \addtoindexi{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
+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.
+
+\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
+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
+the \DWTAGcallsiteparameter{} entry may also have 
+\DWATcalldatalocation{} \addtoindexi{attribute}{call data location attribute}
+whose value is a location expression and a
+\DWATcalldatavalue{} \addtoindexi{attribute}{call data value attribute}
+whose value is a DWARF expression.  The \DWATcalldatalocationNAME{} attribute 
+describes where the referenced value lives during the call.  If it is just 
+\DWOPpushobjectaddress{}, it may be left out.  The 
+\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.
+
+Each call site parameter entry may also have a 
+\DWATcallparameter{} \addtoindexi{attribute}{call parameter entry}
+which contains a reference to a \DWTAGformalparameter{} entry,
+\DWATtype{} attribute referencing the type of the parameter or \DWATname{}
+attribute describing the parameter's name.
+
 
 
 \section{Lexical Block Entries}
 
 
 \section{Lexical Block Entries}
@@ -2113,9 +2312,3 @@ The siblings immediately following
 a try \livelink{chap:tryblock}{block} entry are its
 corresponding catch \livelink{chap:catchblock}{block} entries.
 
 a try \livelink{chap:tryblock}{block} entry are its
 corresponding catch \livelink{chap:catchblock}{block} entries.
 
-
-
-
-
-
-
index 1ef3850..f061ceb 100644 (file)
@@ -54,7 +54,7 @@ format would be represented by a change in the
 \dotdebugstroffsets & x & x & x & 5 \\
 
 \hspace{3cm}\textit{(.dwo sections)}                              \\
 \dotdebugstroffsets & x & x & x & 5 \\
 
 \hspace{3cm}\textit{(.dwo sections)}                              \\
-\dotdebugabbrevdwo  & x & x & x & 5 \\
+\dotdebugabbrevdwo  & x & x & x & - \\
 \dotdebuginfodwo    & x & x & x & 5 \\
 \dotdebuglinedwo    & x & x & x & 5 \\
 \dotdebuglocdwo     & x & x & x & 5 \\
 \dotdebuginfodwo    & x & x & x & 5 \\
 \dotdebuglinedwo    & x & x & x & 5 \\
 \dotdebuglocdwo     & x & x & x & 5 \\
index 84f7f91..68d37b9 100644 (file)
@@ -229,11 +229,13 @@ entry providing start and end offsets relative to the base
 address. 
 \end{itemize}
 An end-of-list entry has no further data. A base address
 address. 
 \end{itemize}
 An end-of-list entry has no further data. A base address
-selection entry contains a single unsigned LEB128 number
+selection entry contains a single unsigned LEB128
+\addtoindexx{LEB128!unsigned} number
 following the entry type byte, which is an index into the
 \dotdebugaddr{} section that selects the new base address for
 subsequent location list entries. A start/end entry contains two
 following the entry type byte, which is an index into the
 \dotdebugaddr{} section that selects the new base address for
 subsequent location list entries. A start/end entry contains two
-unsigned LEB128 numbers following the entry type byte, which are
+unsigned LEB128\addtoindexx{LEB128!unsigned} numbers 
+following the entry type byte, which are
 indices into the \dotdebugaddr{} section that select the beginning
 and ending addresses. A start/length entry contains one unsigned
 LEB128 number and a 4-byte unsigned value (as would be
 indices into the \dotdebugaddr{} section that select the beginning
 and ending addresses. A start/length entry contains one unsigned
 LEB128 number and a 4-byte unsigned value (as would be
index 53da8e0..8204b99 100644 (file)
@@ -1663,18 +1663,19 @@ a \DWATname{} attribute
 \addtoindexx{name attribute}
 whose value is a null\dash terminated
 string containing the enumeration type name as it appears
 \addtoindexx{name attribute}
 whose value is a null\dash terminated
 string containing the enumeration type name as it appears
-in the source program. This entry also has a 
-\DWATbytesize{}
-attribute whose \livelink{chap:classconstant}{integer constant} 
-value is the number of bytes
-required to hold an instance of the enumeration.
+in the source program. 
 
 The \addtoindex{enumeration type entry}
 may have 
 \addtoindexx{type attribute}
 a \DWATtype{} attribute
 which refers to the underlying data type used to implement
 
 The \addtoindex{enumeration type entry}
 may have 
 \addtoindexx{type attribute}
 a \DWATtype{} attribute
 which refers to the underlying data type used to implement
-the enumeration.
+the enumeration. The entry also may have a 
+\DWATbytesize{} attribute whose 
+\livelink{chap:classconstant}{integer constant} value is the number of bytes 
+required to hold an instance of the enumeration. If no \DWATbytesize{} attribute 
+is present, the size for holding an instance of the enumeration is given by the size 
+of the underlying data type.
 
 If an enumeration type has type safe 
 \addtoindexx{type safe enumeration types}
 
 If an enumeration type has type safe 
 \addtoindexx{type safe enumeration types}
@@ -1995,7 +1996,7 @@ a
 which is a \livelink{chap:classflag}{flag}. 
 If present, this attribute indicates whether
 this subrange represents a \addtoindex{UPC} array bound which is scaled
 which is a \livelink{chap:classflag}{flag}. 
 If present, this attribute indicates whether
 this subrange represents a \addtoindex{UPC} array bound which is scaled
-by the runtime THREADS value (the number of UPC threads in
+by the runtime THREADS value (the number of \addtoindex{UPC} threads in
 this execution of the program).
 
 \textit{This allows the representation of a \addtoindex{UPC} shared array such as}
 this execution of the program).
 
 \textit{This allows the representation of a \addtoindex{UPC} shared array such as}
@@ -2357,19 +2358,19 @@ see Appendix \refersec{app:aggregateexamples}.}
 The presence of the
 \hypertarget{chap:DWATrankofdynamicarray}{\DWATrankINDX}
 attribute indicates that an array's rank
 The presence of the
 \hypertarget{chap:DWATrankofdynamicarray}{\DWATrankINDX}
 attribute indicates that an array's rank
-(dimensionality) is dynamic, and therefore unknown at compile
+(number of dimensions) is dynamic, and therefore unknown at compile
 time. The value of the \DWATrankINDX{} attribute is either an integer constant
 or a location expression whose evaluation yields the dynamic rank.
 
 time. The value of the \DWATrankINDX{} attribute is either an integer constant
 or a location expression whose evaluation yields the dynamic rank.
 
-The bounds of an array with dynamic rank are described using the
-\DWTAGgenericsubrange{} tag, which  
+The bounds of an array with dynamic rank are described using a
+\DWTAGgenericsubrange{} entry, which  
 is the dynamic rank array equivalent of
 \DWTAGsubrangetype. The
 is the dynamic rank array equivalent of
 \DWTAGsubrangetype. The
-difference is that a \DWTAGgenericsubrangeINDX{} contains generic
+difference is that a \DWTAGgenericsubrange{} entry contains generic
 lower/upper bound and stride expressions that need to be evaluated for
 lower/upper bound and stride expressions that need to be evaluated for
-each dimension: Before any expression contained in a
-\DWTAGgenericsubrangeINDX{} can be evaluated, the dimension for which the
-expression should be evaluated needs to be pushed onto the stack. The
+each dimension. Before any expression contained in a
+\DWTAGgenericsubrange{} can be evaluated, the dimension for which the
+expression is to be evaluated needs to be pushed onto the stack. The
 expression will use it to find the offset of the respective field in
 the array descriptor metadata.
 
 expression will use it to find the offset of the respective field in
 the array descriptor metadata.