Misc corrections up thru Chpt 5
[dwarf-doc.git] / dwarf5 / latexdoc / typeentries.tex
index 307f779..a3138be 100644 (file)
@@ -152,8 +152,7 @@ order bit of the storage unit used to contain that value.}
 DWARF Versions 3 
 \addtoindexx{DWARF Version 3}
 and 
-\addtoindexx{DWARF Version 4} and 
-4, note that DWARF V4
+\addtoindexx{DWARF Version 4} and 4, note that DWARF V4
 defines the following combinations of attributes:}
 
 \begin{itemize}
@@ -163,9 +162,8 @@ defines the following combinations of attributes:}
 \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size} 
 and optionally \livelink{chap:DWATdatabitoffset}{DW\-\_AT\-\_data\-\_bit\-\_offset}}
 \end{itemize}
-DWARF V3 
+\textit{DWARF V3 defines the following combinations:}
 \addtoindexx{DWARF Version 3}
-defines the following combinations:
 % FIXME: the figure below interferes with the following
 % bullet list, which looks horrible as a result.
 \begin{itemize}
@@ -199,7 +197,7 @@ floating\dash point number \\
 \livetarg{chap:DWATEsignedfixed}{DW\-\_ATE\-\_signed\-\_fixed} & signed fixed\dash point scaled integer \\
 \livetarg{chap:DWATEunsignedfixed}{DW\-\_ATE\-\_unsigned\-\_fixed}& unsigned fixed\dash point scaled integer \\
 \livetarg{chap:DWATEdecimalfloat}{DW\-\_ATE\-\_decimal\-\_float} & decimal floating\dash point number \\ 
-\livetarg{chap:DWATEUTF}{DW\-\_ATE\-\_UTF} & Unicode character \\
+\livetarg{chap:DWATEUTF}{DW\-\_ATE\-\_UTF} & \addtoindex{Unicode} character \\
 \end{tabular}
 \caption{Encoding attribute values}
 \label{fig:encodingattributevalues}
@@ -209,8 +207,8 @@ floating\dash point number \\
 floating\dash point representations that have a power\dash of\dash ten
 exponent, such as that specified in IEEE 754R.}
 
-\textit{The \livelink{chap:DWATEUTF}{DW\-\_ATE\-\_UTF} encoding is intended for Unicode string
-encodings (see the Universal Character Set standard,
+\textit{The \livelink{chap:DWATEUTF}{DW\-\_ATE\-\_UTF} encoding is intended for \addtoindex{Unicode}
+string encodings (see the Universal Character Set standard,
 ISO/IEC 10646\dash 1:1993). For example, the 
 \addtoindex{C++} type char16\_t is
 represented by a base type entry with a name attribute whose
@@ -425,6 +423,9 @@ definition is deferred to a separate compilation unit).
 \addtoindexx{type modifier entry}
 
 A base or user\dash defined type may be modified in different ways
+in different languages. A type modifier is represented in
+DWARF by a debugging information entry with one of the tags
+given in Figure \refersec{fig:typemodifiertags}.
 \addtoindexx{type modifier|see{constant type entry}}
 \addtoindexx{type modifier|see{reference type entry}}
 \addtoindexx{type modifier|see{restricted type entry}}
@@ -432,11 +433,6 @@ A base or user\dash defined type may be modified in different ways
 \addtoindexx{type modifier|see{pointer type entry}}
 \addtoindexx{type modifier|see{shared type entry}}
 \addtoindexx{type modifier|see{volatile type entry}}
-in different languages. 
-A type modifier is represented in
-DWARF by a debugging information entry with one of the tags
-given in 
-Figure \refersec{fig:typemodifiertags}.
 
 If a name has been given to the modified type in the source
 program, then the corresponding modified type entry has
@@ -514,12 +510,12 @@ Name&Meaning\\ \hline
 the type being modified \addtoindexx{pointer qualified type entry} \\
 \livetarg{chap:DWTAGreferencetype}{DW\-\_TAG\-\_reference\-\_type}& C++ (lvalue) reference 
 to an object of the type 
-\addtoindexx{reference type entry} \\
-being modified 
+\addtoindexx{reference type entry}
+being modified
 \addtoindexx{reference qualified type entry} \\
 \livetarg{chap:DWTAGrestricttype}{DW\-\_TAG\-\_restrict\-\_type}& \addtoindex{C} 
 restrict 
-\addtoindexx{restricted type entry} \\
+\addtoindexx{restricted type entry}
 qualified type
 \addtoindexx{restrict qualified type} \\
 \livetarg{chap:DWTAGrvaluereferencetype}{DW\-\_TAG\-\_rvalue\-\_reference\-\_type} & C++
@@ -528,7 +524,7 @@ rvalue
 \addtoindexx{restricted type entry}
 reference to an object of the type being modified 
 \addtoindexx{rvalue reference qualified type entry} \\
-\livetarg{chap:DWTAGsharedtype}{DW\-\_TAG\-\_shared\-\_type}&UPC shared qualified type 
+\livetarg{chap:DWTAGsharedtype}{DW\-\_TAG\-\_shared\-\_type}&\addtoindex{UPC} shared qualified type 
 \addtoindexx{shared qualified type entry} \\
 \livetarg{chap:DWTAGvolatiletype}{DW\-\_TAG\-\_volatile\-\_type}&C or C++ volatile qualified type 
 \addtoindex{volatile qualified type entry} \\
@@ -543,25 +539,30 @@ reference to an object of the type being modified
 declarations:}
 
 \begin{alltt}
-const unsigned char * volatile p;
-    which represents a volatile pointer to a constant
-    character. This is encoded in DWARF as:
+   const unsigned char * volatile p;
+\end{alltt}
+\textit{which represents a volatile pointer to a constant
+character. This is encoded in DWARF as:}
+\begin{alltt}
         \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable}(p) -->
             \livelink{chap:DWTAGvolatiletype}{DW\-\_TAG\-\_volatile\-\_type} -->
                 \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type} -->
                     \livelink{chap:DWTAGconsttype}{DW\-\_TAG\-\_const\-\_type} -->
                         \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}(unsigned char)
-
-volatile unsigned char * const restrict p;
-    on the other hand, represents a restricted constant
-    pointer to a volatile character. This is encoded as:
+\end{alltt}
+\textit{On the other hand}
+\begin{alltt}                        
+   volatile unsigned char * const restrict p;
+\end{alltt}
+\textit{represents a restricted constant
+pointer to a volatile character. This is encoded as:}
+\begin{alltt}
         \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable}(p) -->
             \livelink{chap:DWTAGrestricttype}{DW\-\_TAG\-\_restrict\-\_type} -->
                 \livelink{chap:DWTAGconsttype}{DW\-\_TAG\-\_const\-\_type} -->
                     \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type} -->
                         \livelink{chap:DWTAGvolatiletype}{DW\-\_TAG\-\_volatile\-\_type} -->
                             \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}(unsigned char)
-
 \end{alltt}
 
 \section{Typedef Entries}
@@ -599,14 +600,13 @@ source syntax) in other languages.}
 \section{Array Type Entries}
 \label{chap:arraytypeentries}
 
-Many languages share the concept of an ``array,'' which is
+\textit{Many languages share the concept of an ``array,'' which is
 \addtoindexx{array type entry}
-a table of components of identical type.
+a table of components of identical type.}
 
 An array type is represented by a debugging information entry
 with the tag \livetarg{chap:DWTAGarraytype}{DW\-\_TAG\-\_array\-\_type}. 
-If a name has been 
-given to
+If a name has been given to
 \addtoindexx{array!declaration of type}
 the array type in the source program, then the corresponding
 array type entry has a \livelink{chap:DWATname}{DW\-\_AT\-\_name} attribute 
@@ -694,10 +694,10 @@ array type entry and are ordered to reflect the appearance of
 the dimensions in the source program (i.e., leftmost dimension
 first, next to leftmost second, and so on).
 
-In languages, such as C, in which there is no concept of
+\textit{In languages, such as C, in which there is no concept of
 a “multidimensional array”, an array of arrays may
 be represented by a debugging information entry for a
-multidimensional array.
+multidimensional array.}
 
 Other attributes especially applicable to arrays are
 \livelink{chap:DWATallocated}{DW\-\_AT\-\_allocated}, 
@@ -705,9 +705,7 @@ Other attributes especially applicable to arrays are
 \livelink{chap:DWATdatalocation}{DW\-\_AT\-\_data\-\_location},
 which are described in 
 Section \refersec{chap:dynamictypeproperties}. 
-For relevant examples,
-see also 
-Appendix \refersec{app:fortran90example}.
+For relevant examples, see also Appendix \refersec{app:fortran90example}.
 
 \section{ Structure, Union, Class and Interface Type Entries}
 \label{chap:structureunionclassandinterfacetypeentries}
@@ -786,7 +784,8 @@ either a \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} or a
 (see Section \refersec{chap:byteandbitsizes}), 
 whose value is the amount of storage needed
 to hold an instance of the structure, union or class type,
-including any padding.  
+including any padding.
+  
 An incomplete structure, union or class type 
 \addtoindexx{incomplete structure/union/class}
 is 
@@ -1835,7 +1834,7 @@ attribute is interpreted as bytes.
 \section{Subroutine Type Entries}
 \label{chap:subroutinetypeentries}
 
-It is possible in \addtoindex{C}
+\textit{It is possible in \addtoindex{C}
 to declare pointers to subroutines
 that return a value of a specific type. In both 
 \addtoindex{C} and \addtoindex{C++},
@@ -1843,7 +1842,7 @@ it is possible to declare pointers to subroutines that not
 only return a value of a specific type, but accept only
 arguments of specific types. The type of such pointers would
 be described with a ``pointer to'' modifier applied to a
-user\dash defined type.
+user\dash defined type.}
 
 A subroutine type is represented by a debugging information
 entry with the 
@@ -1869,10 +1868,10 @@ arguments. These debugging information entries appear in the
 order that the corresponding argument types appear in the
 source program.
 
-In \addtoindex{C} there 
+\textit{In \addtoindex{C} there 
 is a difference between the types of functions
 declared using function prototype style declarations and
-those declared using non\dash prototype declarations.
+those declared using non\dash prototype declarations.}
 
 A 
 \hypertarget{chap:DWATprototypedsubroutineprototype}
@@ -1910,15 +1909,14 @@ tag \livelink{chap:DWTAGunspecifiedparameters}{DW\-\_TAG\-\_unspecified\-\_param
 \section{String Type Entries}
 \label{chap:stringtypeentries}
 
-
-A ``string'' is a sequence of characters that have specific
+\textit{A ``string'' is a sequence of characters that have specific
 \addtoindexx{string type entry}
 semantics and operations that separate them from arrays of
 characters. 
 \addtoindex{Fortran} is one of the languages that has a string
 type. Note that ``string'' in this context refers to a target
 machine concept, not the class string as used in this document
-(except for the name attribute).
+(except for the name attribute).}
 
 A string type is represented by a debugging information entry
 with the tag \livetarg{chap:DWTAGstringtype}{DW\-\_TAG\-\_string\-\_type}. 
 \livelink{chap:DWATthreadsscaled}{DW\-\_AT\-\_threads\-\_scaled} attribute,
 which is a \livelink{chap:flag}{flag}. 
 If present, this attribute indicates whether
-this subrange represents a UPC array bound which is scaled
+this subrange represents a \addtoindex{UPC} array bound which is scaled
 by the runtime THREADS value (the number of UPC threads in
 this execution of the program).
 
-\textit{This allows the representation of a UPC shared array such as}
+\textit{This allows the representation of a \addtoindex{UPC} shared array such as}
 
 \begin{lstlisting}
 int shared foo[34*THREADS][10][20];
@@ -2052,7 +2050,9 @@ subrange
 \hypertarget{chap:DWATupperboundupperboundofsubrange}
 entry may have the attributes 
 \livelink{chap:DWATlowerbound}{DW\-\_AT\-\_lower\-\_bound}
-and \livelink{chap:DWATupperbound}{DW\-\_AT\-\_upper\-\_bound} to specify, respectively, the lower
+\addtoindexx{lower bound attribute}
+and \livelink{chap:DWATupperbound}{DW\-\_AT\-\_upper\-\_bound}
+\addtoindexx{upper bound attribute} to specify, respectively, the lower
 and upper bound values of the subrange. The 
 \livelink{chap:DWATupperbound}{DW\-\_AT\-\_upper\-\_bound}
 attribute 
@@ -2073,8 +2073,7 @@ Section \refersec{chap:staticanddynamicvaluesofattributes}.
 If the lower bound value is missing, the value is assumed to
 be a language\dash dependent default constant. 
 \addtoindexx{lower bound attribute!default}
-The default lower
-bound is 0 for 
+The default lower bound is 0 for 
 \addtoindex{C}, \addtoindex{C++}, 
 \addtoindex{D}, 
 \addtoindex{Java}, 
@@ -2092,7 +2091,7 @@ The default lower bound is 1 for
 \textit{No other default lower bound values are currently defined.}
 
 If the upper bound and count are missing, then the upper bound value is 
-\textit{unknown}.
+\textit{unknown}.\addtoindexx{upper bound attribute!default unknown}
 
 If the subrange entry has no type attribute describing the
 basis type, the basis type is assumed to be the same as
@@ -2166,6 +2165,7 @@ has
 \addtoindex{pointer to member entry} 
 a 
 \livelink{chap:DWATuselocation}{DW\-\_AT\-\_use\-\_location} attribute
+\addtoindexx{use location attribute}
 whose value is a 
 \addtoindex{location description} that computes the
 address of the member of the class to which the pointer to
@@ -2308,10 +2308,10 @@ indicates that objects of the type can be associated. The
 integer value of the attribute (see below) indicates whether
 an object of the type is currently associated or not.
 
-While these attributes are defined specifically with 
+\textit{While these attributes are defined specifically with 
 \addtoindex{Fortran 90} ALLOCATABLE and POINTER types
 in mind, usage is not limited
-to just that language.
+to just that language.}
 
 The value of these attributes is determined as described in
 Section \refersec{chap:staticanddynamicvaluesofattributes}.