Indexing the b* entries, completed here.
authorDavid Anderson <davea42@earthlink.net>
Mon, 15 Oct 2012 16:38:57 +0000 (09:38 -0700)
committerDavid Anderson <davea42@earthlink.net>
Mon, 15 Oct 2012 16:38:57 +0000 (09:38 -0700)
A few "See Section" things were not proper \refersec, fixed thouse.
A few instances of "something" were present and those are now
in latex form ``something'' . Except in examples, where "" is
fine as is.

dwarf5/latexdoc/compression.tex
dwarf5/latexdoc/dataobject.tex
dwarf5/latexdoc/examples.tex
dwarf5/latexdoc/generaldescription.tex
dwarf5/latexdoc/introduction.tex
dwarf5/latexdoc/otherdebugginginformation.tex
dwarf5/latexdoc/programscope.tex
dwarf5/latexdoc/sectionversionnumbers.tex
dwarf5/latexdoc/typeentries.tex

index da4d351..372da78 100644 (file)
@@ -179,7 +179,8 @@ Section \refersec{app:examples}.
 
 \textbf{Section Group Names}
 
-Section groups must have a section group name. For the subsequent C++ example, a name like
+Section groups must have a section group name. For the subsequent 
+\addtoindex{C++} example, a name like
 
 <producer-prefix>.<file-designator>.<gid-number>
 
@@ -317,7 +318,7 @@ An \#include directive appearing outside any other
 declarations is a good candidate to be represented using
 \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}. 
 However, an \#include appearing inside
-a C++ namespace declaration or a function, for example, is
+a \addtoindex{C++} namespace declaration or a function, for example, is
 not a good candidate because the entities included are not
 necessarily file level entities.
 
@@ -405,7 +406,7 @@ the underlying object language is not (and varies from system to system).
 
 \subsubsection{C++ Example}
 
-The C++ source in 
+The addtoindex{C++} source in 
 Section \refersec{app:duplicateeliminationexample1csource}
 is used to illustrate the DWARF
 representation intended to allow duplicate elimination.
@@ -492,7 +493,8 @@ in the section group shown above.
 
 This example uses \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit} for the section group,
 implying that the contents of the compilation unit are
-globally visible (in accordance with C++ language rules).
+globally visible (in accordance with 
+\addtoindex{C++} language rules).
 \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} is not needed for the same reason.
 
 \subsubsection{Fortran Example}
@@ -658,13 +660,15 @@ visible as global entities.
 
 \subsubsection{C Example}
 
-The C++ example in this Section might appear to be equally
-valid as a C example. However, it is prudent to include
-a \livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit} in the primary unit (see Figure 84)
+The \addtoindex{C++} example in this Section might appear to be equally
+valid as a \addtoindex{C} example. However, it is prudent to include
+a \livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit}
+in the primary unit 
+(see Figure \refersec{app:duplicateeliminationexample1primarycompilationunit})
 with an \livelink{chap:DWATimport}{DW\-\_AT\-\_import} attribute that refers to the proper unit
 in the section group.
 
-\textit{The C rules for consistency of global (file scope) symbols
+\textit{The \addtoindex{C} rules for consistency of global (file scope) symbols
 across compilations are less strict than for C++; inclusion
 of the import unit attribute assures that the declarations of
 the proper section group are considered before declarations
@@ -717,7 +721,7 @@ Section \refersec{datarep:typesignaturecomputation}.
 \subsection{Signature Computation Example}
 \label{app:signaturecomputationexample}
 
-As an example, consider a C++ header file 
+As an example, consider a \addtoindex{C++} header file 
 containing the type definitions shown
 in Section \refersec{app:typesignatureexamplescsource}.
 
@@ -1192,9 +1196,12 @@ empty
 \subsection{\#include compression}
 \label{app:includecompression}
 
-C++ has a much greater problem than C with the number and
+\addtoindex{C++} has a much greater 
+problem than 
+\addtoindex{C} with the number and
 size of the headers included and the amount of data in each,
-but even with C there is substantial header file information
+but even with \addtoindex{C} 
+there is substantial header file information
 duplication.
 
 A reasonable approach is to put each header file in its own
index 54a0cbc..9f62de5 100644 (file)
@@ -147,14 +147,17 @@ containing scope is contiguous, the value of this attribute
 is the offset in bytes of the beginning of the scope for the
 object from the low pc value of the debugging information
 entry that defines its scope. If the containing scope
-is non-contiguous (see Section 2.17.3), the value of this
+is non-contiguous 
+(see \refersec{chap:noncontiguousaddressranges})
+the value of this
 attribute is the offset in bytes of the beginning of the scope
 for the object from the beginning of the first range list entry
 that is not a base selection entry or an end of list entry.
 
 \item Otherwise, the scope of the object is specified using
 a value of class \livelink{chap:rangelistptr}{rangelistptr}. This value indicates the
-beginning of a range list (see Section 2.17.3).
+beginning of a range list
+(see \refersec{chap:noncontiguousaddressranges}).
 \end{enumerate}
 
 
@@ -187,9 +190,15 @@ the containing scope is contiguous. Conversely, the scope of
 an object may not require its own range list even when the
 containing scope is non\dash contiguous.}
 
-\item A \livelink{chap:DWATendianity}{DW\-\_AT\-\_endianity} attribute, whose value is a constant
+\item A \livelink{chap:DWATendianity}{DW\-\_AT\-\_endianity} attribute, 
+whose value 
 \hypertarget{chap:DWATendianityendianityofdata}
-that specifies the endianity of the object. The value of
+is a constant
+\addtoindexx{endianity attribute}
+that 
+\addtoindexx{big-endian encoding|see{endianity attribute}}
+specifies 
+the endianity of the object. The value of
 this attribute specifies an ABI\dash defined byte ordering for
 the value of the object. If omitted, the default endianity
 of data for the given type is assumed.  The set of values
index 66d07bc..4f3ae06 100644 (file)
@@ -620,8 +620,8 @@ of this example and therefore not shown.
 
 The Pascal source in 
 Figure \refersec{fig:packedrecordexamplesourcefragment}
-is used to illustrate the representation of packed unaligned bit
-fields.
+is used to illustrate the representation of packed unaligned
+\addtoindex{bit fields}.
 \begin{figure}[here]
 \begin{lstlisting}
 TYPE T : PACKED RECORD ! bit size is 2
@@ -670,9 +670,9 @@ Section \refersec{chap:datamemberentries}.
             \livelink{chap:DWATlowerbound}{DW\-\_AT\-\_lower\-\_bound}(0)
             \livelink{chap:DWATupperbound}{DW\-\_AT\-\_upper\-\_bound}(1)
         \livelink{chap:DWATbitstride}{DW\-\_AT\-\_bit\-\_stride}(2)
-        \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size}(4)
+        \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size}(4) \addtoindexx{bit size attribute}
 23\$: \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type} ! anonymous type for V
-        \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size}(39)
+        \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size}(39) \addtoindexx{bit size attribute}
         \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
             \livelink{chap:DWATname}{DW\-\_AT\-\_name}("F1")
             \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 10\$)
@@ -692,7 +692,7 @@ Section \refersec{chap:datamemberentries}.
             \livelink{chap:DWATname}{DW\-\_AT\-\_name}("F7")
             \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 20\$) ! type T
             \livelink{chap:DWATdatabitoffset}{DW\-\_AT\-\_data\-\_bit\-\_offset}(37)
-            \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size}(2) ! may be omitted
+            \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size}(2) \addtoindexx{bit size attribute}! may be omitted
      \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable}
         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("V")
         \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 23\$)
index 4941304..e05f740 100644 (file)
@@ -380,8 +380,8 @@ Attribute Class & General Use and Encoding \\ \hline
  \\
 \livetargi{chap:constant}{constant}{constant class}
 &One, two, four or eight bytes of uninterpreted data, or data
-encoded in the variable length format known as LEB128 (see
-Section 7.6.).
+encoded in the variable length format known as LEB128 
+(see Section \refersec{datarep:variablelengthdata}).
 
 \textit{Most constant values are integers of one kind or
 another (codes, offsets, counts, and so on); these are
@@ -471,7 +471,7 @@ The tree itself is represented
 by flattening it in prefix order. 
 Each debugging information
 entry is defined either to have child entries or not to have
-child entries (see Section 7.5.3). 
+child entries (see Section \refersec{datarep:abbreviationstables}). 
 If an entry is defined not
 to have children, the next physically succeeding entry is a
 sibling. 
@@ -741,7 +741,8 @@ operation belongs to the main executable's DWARF info, the
 operation uses the main executable's thread\dash local storage
 \nolink{block}; if the expression belongs to a shared library's
 DWARF info, then it uses that shared library's thread\dash local
-storage \nolink{block}.  Some implementations of C and C++ support a
+storage \nolink{block}.  Some implementations of 
+\addtoindex{C} and \addtoindex{C++} support a
 \_\_thread storage class. Variables with this storage class
 have distinct values and addresses in distinct threads, much
 as automatic variables have distinct values and addresses in
@@ -1595,7 +1596,7 @@ also a definition, or is otherwise incomplete, to evaluate
 \hypertarget{chap:DWATdeclarationincompletenondefiningorseparateentitydeclaration}
 an expression correctly.
 
-\textit{As an example, consider the following fragment of C code:}
+\textit{As an example, consider the following fragment of \addtoindex{C} code:}
 
 \begin{lstlisting}
 void myfunc()
@@ -1609,7 +1610,7 @@ void myfunc()
 \end{lstlisting}
 
 
-\textit{C scoping rules require that the 
+\textit{\addtoindex{C} scoping rules require that the 
 value of the variable x passed to the function g is the value of the
 global variable x rather than of the local version.}
 
@@ -1666,7 +1667,8 @@ The value of the \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} attribut
 a file number from the line number information table for the
 compilation unit containing the debugging information entry and
 represents the source file in which the declaration appeared
-(see Section 6.2). The value 0 indicates that no source file
+(see Section \refersec{chap:linenumberinformation}). 
+The value 0 indicates that no source file
 has been specified.
 
 The value of the \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} attribute represents
@@ -1710,7 +1712,7 @@ includes variables and parameters) or
 common \livelink{chap:commonblockentry}{block}
 may have a
 \livelink{chap:DWATlocation}{DW\-\_AT\-\_location} attribute, whose value is a location description
-(see Section 2.6).  
+(see Section \refersec{chap:locationdescriptions}).
 
 A DWARF procedure is represented by any
 kind of debugging information entry that has a \livelink{chap:DWATlocation}{DW\-\_AT\-\_location}
@@ -1862,7 +1864,8 @@ containing only an end of list entry describes an empty scope
 \textit{A base address selection entry and an end of list entry for
 a range list are identical to a base address selection entry
 and end of list entry, respectively, for a location list
-(see Section 2.6.2) in interpretation and representation.}
+(see Section \refersec{chap:locationlists}) 
+in interpretation and representation.}
 
 
 
@@ -1961,7 +1964,7 @@ assigned, or the like.}
 Many debugging information entries allow either a
 \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} attribute or a \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size} attribute,
 whose integer constant value 
-(see \refersec{chap:staticanddynamicvaluesofattributes}) 
+(see Section \refersec{chap:staticanddynamicvaluesofattributes}) 
 specifies an
 amount of storage. The value of the \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} attribute
 is interpreted in bytes and the value of the \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size}
@@ -1974,10 +1977,11 @@ attribute is interpreted in bits.
 
 \section{Linkage Names}
 \label{chap:linkagenames}
-\textit{Some language implementations, notably C++ and similar
+\textit{Some language implementations, notably 
+\addtoindex{C++} and similar
 languages, make use of implementation defined names within
 object files that are different from the identifier names
-(see \refersec{chap:identifiernames}) of entities as they appear in the
+(see Section \refersec{chap:identifiernames}) of entities as they appear in the
 source. Such names, sometimes known as mangled names,
 are used in various ways, such as: to encode additional
 information about an entity, to distinguish multiple entities
index 868d4ef..402df16 100644 (file)
@@ -24,13 +24,15 @@ designed to meet the symbolic, source-level debugging needs of
 different languages in a unified fashion by requiring language
 independent debugging information whenever possible.  
 Aspects
-of individual languages, such as C++ virtual functions or
-Fortran common \nolink{blocks}, are accommodated by creating attributes
+of individual languages, such as \addtoindex{C++} virtual functions or
+\addtoindex{Fortran} common 
+\nolink{blocks}, are accommodated by creating attributes
 that are used only for those languages. 
 This document is
 believed to cover most debugging information needs of 
 addtoindex{Ada},
-C, C++, COBOL, and Fortran; it also covers the basic needs
+\addtoindex{C}, \addtoindex{C++}, \addtoindex{COBOL}, 
+and \addtoindex{Fortran}; it also covers the basic needs
 of various other languages.
 
 This document describes DWARF Version 4, the fourth generation
@@ -185,13 +187,13 @@ Add support for Fortran 90 modules as well as allocatable
 array and pointer types.
 
 \item
-Add additional base types for C (as revised for 1999).
+Add additional base types for \addtoindex{C} (as revised for 1999).
 
 \item
-Add support for Java and COBOL.
+Add support for \addtoindex{Java} and \addtoindex{COBOL}.
 
 \item
-Add namespace support for C++.
+Add namespace support for \addtoindex{C++}.
 
 \item
 Add an optional section for global type names (similar to
index d9f769b..5a0d9a7 100644 (file)
@@ -994,7 +994,9 @@ gives some sample line number programs.}
 
 \section{Macro Information}
 \label{chap:macroinformation}
-\textit{Some languages, such as C and C++, provide a way to replace
+\textit{Some languages, such as 
+\addtoindex{C} and 
+addtoindex{C++}, provide a way to replace
 text in the source program with macros defined either in the
 source file itself, or in another file included by the source
 file.  Because these macros are not themselves defined in the
@@ -1005,7 +1007,9 @@ the macro definition has been expanded, rather than as the
 programmer wrote it. The macro information table provides a way
 of preserving the original source in the debugging information.}
 
-As described in Section 3.1.1, the macro information for a
+As described in 
+Section \refersec{chap:normalandpartialcompilationunitentries},
+the macro information for a
 given compilation unit is represented in the 
 \addtoindex{.debug\_macinfo}
 section of an object file. The macro information for each
index 81a75b8..4b88e8c 100644 (file)
@@ -243,9 +243,10 @@ subprogram that has been identified as the starting function
 of the program. If more than one compilation unit contains
 this \nolink{flag}, any one of them may contain the starting function.
 
-\textit{Fortran has a PROGRAM statement which is used
+\textit{\addtoindex{Fortran} has a PROGRAM statement which is used
 to specify and provide a user\dash specified name for the main
-subroutine of a program. C uses the name “main” to identify
+subroutine of a program. 
+\addtoindex{C} uses the name “main” to identify
 the main subprogram of a program. Some other languages provide
 similar or other means to identify the main subprogram of
 a program.}
@@ -336,10 +337,11 @@ those entities.}
 \subsection{Module Entries}
 \label{chap:moduleentries}
 \textit{Several languages have the concept of a ``module.''
+\addtoindexx{Modula-2}
 A Modula\dash 2 definition module may be represented by a module
 entry containing a declaration attribute (\livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration}). A
-Fortran 90 module may also be represented by a module entry
-(but no declaration attribute is warranted because Fortran
+\addtoindex{Fortran 90} module may also be represented by a module entry
+(but no declaration attribute is warranted because \addtoindex{Fortran}
 has no concept of a corresponding module body).}
 
 A module is represented by a debugging information entry
@@ -376,7 +378,7 @@ represented as it would be on the target architecture.
 
 \subsection{Namespace Entries}
 \label{chap:namespaceentries}
-\textit{C++ has the notion of a namespace, which provides a way to
+\textit{\addtoindex{C++} has the notion of a namespace, which provides a way to
 implement name hiding, so that names of unrelated things
 do not accidentally clash in the global namespace when an
 application is linked together.}
@@ -405,7 +407,8 @@ Namespace and namespace extension entries may own other
 debugging information entries describing program entities
 whose declarations occur in the namespace.
 
-\textit{For C++, such owned program entities may be declarations,
+\textit{For \addtoindex{C++}, such 
+owned program entities may be declarations,
 including certain declarations that are also object or
 function definitions.}
 
@@ -419,13 +422,16 @@ entries with a \livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} attr
 to duplicate information provided by the declaration entry
 referenced by the specification attribute.
 
-\textit{The C++ global namespace (the namespace referred to by
+\textit{The \addtoindex{C++} global namespace
+(the namespace referred to by
 ``::f'', for example) is not explicitly represented in
 DWARF with a namespace entry (thus mirroring the situation
-in C++ source).  Global items may be simply declared with no
+in \addtoindex{C++} source).  
+Global items may be simply declared with no
 reference to a namespace.}
 
-\textit{The C++ compilation unit specific ``unnamed namespace'' may
+\textit{The \addtoindex{C++} 
+compilation unit specific ``unnamed namespace'' may
 be represented by a namespace entry with no name attribute in
 the original namespace declaration entry (and therefore no name
 attribute in any namespace extension entry of this namespace).
@@ -437,18 +443,21 @@ final namespace declaration of a compilation unit; this is a
 quality\dash of\dash implementation issue and no specific requirements
 are given here. If only the final namespace is represented,
 it is impossible for a debugger to interpret using declaration
-references in exactly the manner defined by the C++ language.
+references in exactly the manner defined by the 
+\addtoindex{C++} language.
 }
 
 \textit{Emitting all namespace declaration information in all
 compilation units can result in a significant increase in the
 size of the debug information and significant duplication of
-information across compilation units. The C++ namespace std,
+information across compilation units. 
+The \addtoindex{C++} namespace std,
 for example, is large and will probably be referenced in
-every C++ compilation unit.
+every \addtoindex{C++} compilation unit.
 }
 
-\textit{For a C++ namespace example, see Appendix \refersec{app:namespaceexample}.
+\textit{For a \addtoindex{C++} namespace example, 
+see Appendix \refersec{app:namespaceexample}.
 }
 
 
@@ -492,7 +501,7 @@ used as a general means to rename or provide an alias for
 an entity, regardless of the context in which the importing
 declaration or the imported entity occurs.
 
-\textit{A C++ namespace alias may be represented by an imported
+\textit{A \addtoindex{C++} namespace alias may be represented by an imported
 \hypertarget{chap:DWATimportnamespacealias}
 declaration entry with a name attribute whose value is
 a null\dash terminated string containing the alias name as it
@@ -501,18 +510,19 @@ value is a reference to the applicable original namespace or
 namespace extension entry.
 }
 
-\textit{A C++ using declaration may be represented by one or more
+\textit{A \addtoindex{C++} using declaration may be represented by one or more
 \hypertarget{chap:DWATimportnamespaceusingdeclaration}
 imported declaration entries.  When the using declaration
 refers to an overloaded function, there is one imported
 declaration entry corresponding to each overloading. Each
 imported declaration entry has no name attribute but it does
 have an import attribute that refers to the entry for the
-entity being imported. (C++ provides no means to ``rename''
+entity being imported. (\addtoindex{C++} 
+provides no means to ``rename''
 an imported entity, other than a namespace).
 }
 
-\textit{A Fortran use statement with an ``only list'' may be
+\textit{A \addtoindex{Fortran} use statement with an ``only list'' may be
 represented by a series of imported declaration entries,
 one (or more) for each entity that is imported. An entity
 that is renamed in the importing context may be represented
@@ -546,21 +556,23 @@ name in that module. Any entity in the module that is not
 renamed in this way is known in the context of the imported
 module entry by the same name as it is declared in the module.
 
-\textit{A C++ using directive may be represented by an imported module
+\textit{A \addtoindex{C++} using directive 
+may be represented by an imported module
 \hypertarget{chap:DWATimportnamespaceusingdirective}
 entry, with an import attribute referring to the namespace
 entry of the appropriate extension of the namespace (which
 might be the original namespace entry) and no owned entries.
 }
 
-\textit{A Fortran use statement with a “rename list” may be
+\textit{A \addtoindex{Fortran} use statement with a “rename list” may be
 represented by an imported module entry with an import
 attribute referring to the module and owned entries
 corresponding to those entities that are renamed as part of
 being imported.
 }
 
-\textit{A Fortran use statement with neither a “rename list” nor
+\textit{A \addtoindex{Fortran} use statement 
+with neither a “rename list” nor
 an “only list” may be represented by an imported module
 entry with an import attribute referring to the module and
 no owned child entries.
@@ -571,7 +583,7 @@ series of individual imported declaration entries as described
 in Section \refersec{chap:importedorrenameddeclarationentries}.
 }
 
-\textit{A Fortran use statement for an entity in a module that is
+\textit{A \addtoindex{Fortran} use statement for an entity in a module that is
 itself imported by a use statement without an explicit mention
 may be represented by an imported declaration entry that refers
 to the original debugging information entry. For example, given
@@ -594,7 +606,7 @@ the imported declaration entry for Q within module C refers
 directly to the variable declaration entry for A in module A
 because there is no explicit representation for X in module B.
 
-A similar situation arises for a C++ using declaration that
+A similar situation arises for a \addtoindex{C++} using declaration that
 imports an entity in terms of a namespace alias. See 
 Appendix  \refersec{app:namespaceexample}
 for an example.
@@ -642,7 +654,7 @@ the program.  If more than one subprogram contains this
 \nolink{flag},
 any one of them may be the starting subroutine of the program.
 
-\textit{Fortran has a PROGRAM statement which is used to specify
+\textit{\addtoindex{Fortran} has a PROGRAM statement which is used to specify
 and provide a user\dash supplied name for the main subroutine of
 a program.
 }
@@ -688,13 +700,14 @@ then the debugging information entry for such a subroutine
 may have a calling convention attribute whose value is the
 constant \livetarg{chap:DWCCprogram}{DW\-\_CC\-\_program}.
 
-\textit{The \livelink{chap:DWCCprogram}{DW\-\_CC\-\_program} value is intended to support Fortran main
+\textit{The \livelink{chap:DWCCprogram}{DW\-\_CC\-\_program} value is intended to support \addtoindex{Fortran} main
 programs which in some implementations may not be callable
 or which must be invoked in a special way. It is not intended
 as a way of finding the entry address for the program.
 }
 
-\textit{In C there is a difference between the types of functions
+\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.
 }
@@ -704,13 +717,15 @@ declaration may have a
 \livelink{chap:DWATprototyped}{DW\-\_AT\-\_prototyped} attribute, which is
 a \livelink{chap:flag}{flag}.
 
-\textit{The Fortran language allows the keywords elemental, pure
+\textit{The \addtoindex{Fortran} 
+language allows the keywords elemental, pure
 and recursive to be included as part of the declaration of
 a subroutine; these attributes reflect that usage. These
 attributes are not relevant for languages that do not support
 similar keywords or syntax. In particular, the \livelink{chap:DWATrecursive}{DW\-\_AT\-\_recursive}
 attribute is neither needed nor appropriate in languages such
-as C where functions support recursion by default.
+as \addtoindex{C} 
+where functions support recursion by default.
 }
 
 A subprogram entry 
@@ -750,7 +765,8 @@ the subroutine or entry point is a function that returns a
 value, then its debugging information entry has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type}
 attribute to denote the type returned by that function.
 
-\textit{Debugging information entries for C void functions should
+\textit{Debugging information entries for 
+\addtoindex{C} void functions should
 not have an attribute for the return type.  }
 
 
@@ -822,7 +838,9 @@ represented by a debugging information entry with the tag
 \livetarg{chap:DWTAGunspecifiedparameters}{DW\-\_TAG\-\_unspecified\-\_parameters}.
 
 The entry for a subroutine that includes a 
-Fortran \livelink{chap:fortrancommonblock}{common} \livelink{chap:commonblockentry}{block}
+\addtoindex{Fortran} 
+\livelink{chap:fortrancommonblock}{common} 
+\livelink{chap:commonblockentry}{block}
 \addtoindexx{common block|see{Fortran common block}}
 has a child entry with the 
 tag \livetarg{chap:DWTAGcommoninclusion}{DW\-\_TAG\-\_common\-\_inclusion}. 
@@ -926,7 +944,7 @@ within the context of the parent.}
 \subsection{Types Thrown by Exceptions}
 \label{chap:typesthrownbyexceptions}
 
-\textit{In C++ a subroutine may declare a set of types which
+\textit{In \addtoindex{C++} a subroutine may declare a set of types which
 it may validly throw.}
 
 If a subroutine explicitly declares that it may throw
@@ -942,7 +960,7 @@ exception that may be thrown.
 \subsection{Function Template Instantiations}
 \label{chap:functiontemplateinstantiations}
 
-\textit{In C++, a function template is a generic definition of
+\textit{In \addtoindex{C++}, a function template is a generic definition of
 a function that is instantiated differently when called with
 values of different types. DWARF does not represent the generic
 template definition, but does represent each instantiation.}
@@ -1016,7 +1034,7 @@ Name&Meaning\\ \hline
 \end{tabular}
 \end{figure}
 
-\textit{In C++, a function or a constructor declared with
+\textit{In \addtoindex{C++}, a function or a constructor declared with
 constexpr is implicitly declared inline. The abstract inline
 instance (see below) is represented by a debugging information
 entry with the tag \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}. Such an entry has a
@@ -1053,7 +1071,7 @@ Each abstract instance root is either part of a larger
 tree (which gives a context for the root) or uses
 \livelink{chap:DWATspecification}{DW\-\_AT\-\_specification} to refer to the declaration in context.
 
-\textit{For example, in C++ the context might be a namespace
+\textit{For example, in \addtoindex{C++} the context might be a namespace
 declaration or a class declaration.}
 
 \textit{Abstract instance trees are defined so that no entry is part
@@ -1150,7 +1168,7 @@ representation of the subroutine's return value. The value of
 this attribute is the actual return value of the subroutine,
 represented as it would be on the target architecture.
 
-\textit{In C++, if a function or a constructor declared with constexpr
+\textit{In \addtoindex{C++}, if a function or a constructor declared with constexpr
 is called with constant expressions, then the corresponding
 concrete inlined instance has a \livelink{chap:DWATconstexpr}{DW\-\_AT\-\_const\-\_expr} attribute,
 as well as a \livelink{chap:DWATconstvalue}{DW\-\_AT\-\_const\-\_value} attribute whose value represents
@@ -1271,7 +1289,8 @@ points where those subroutines are actually called. Such
 concrete instances of inlined subroutines are referred to as
 ``concrete out\dash of\dash line instances.''
 
-\textit{In C++, for example, taking the address of a function declared
+\textit{In \addtoindex{C++}, for example, 
+taking the address of a function declared
 to be inline can necessitate the generation of a concrete
 out\dash of\dash line instance of the given function.}
 
@@ -1403,7 +1422,8 @@ The target subprogram may itself be a trampoline. (A sequence
 of trampolines necessarily ends with a non\dash trampoline
 subprogram.)
 
-\textit{In C++, trampolines may be used to implement derived virtual
+\textit{In \addtoindex{C++}, trampolines may be used 
+to implement derived virtual
 member functions; such trampolines typically adjust the
 implicit this pointer parameter in the course of passing
 control.  Other languages and environments may use trampolines
@@ -1432,7 +1452,8 @@ which can be assumed to be the target subroutine. }
 
 \textit{A lexical \livetargi{chap:lexicalblock}{block}{lexical block} is a bracketed sequence of source statements
 that may contain any number of declarations. In some languages
-(including C and C++), \nolink{blocks} can be nested within other
+(including \addtoindex{C} and \addtoindex{C++}),
+\nolink{blocks} can be nested within other
 \nolink{blocks} to any depth.}
 
 % We do not need to link to the preceeding paragraph.
@@ -1461,7 +1482,8 @@ containing the name of the lexical \livelink{chap:lexicalblock}{block}
 as it appears in
 the source program.
 
-\textit{This is not the same as a C or C++ label (see below).}
+\textit{This is not the same as a \addtoindex{C} or 
+\addtoindex{C++} label (see below).}
 
 The lexical \livelink{chap:lexicalblockentry}{block} entry owns 
 debugging information entries that
@@ -1496,7 +1518,9 @@ the name of the label as it appears in the source program.
 \section{With Statement Entries}
 \label{chap:withstatemententries}
 
-\textit{Both Pascal and Modula\dash 2 support the concept of a ``with''
+\textit{Both \addtoindex{Pascal} and 
+\addtoindexx{Modula-2}
+Modula\dash 2 support the concept of a ``with''
 statement. The with statement specifies a sequence of
 executable statements within which the fields of a record
 variable may be referenced, unqualified by the name of the
@@ -1522,7 +1546,7 @@ the with statement.
 \section{Try and Catch Block Entries}
 \label{chap:tryandcatchblockentries}
 
-\textit{In C++ a lexical \livelink{chap:lexicalblock}{block} may be 
+\textit{In \addtoindex{C++} a lexical \livelink{chap:lexicalblock}{block} may be 
 designated as a ``catch \nolink{block}.'' 
 A catch \livetargi{chap:catchblock}{block}{catch block} is an 
 exception handler that handles
index 23758c2..1990131 100644 (file)
@@ -57,13 +57,13 @@ and \addtoindex{.debug\_types} section version number.
 Notes:
 
 \begin{itemize}
-\item  "V2" means DWARF Version 2, published July 1993.
-\item  "V3" means DWARF Version 3, published December 2005.
-\item  "V4" means DWARF Version 4, published June 2010.
-\item  "-" means that a version number is not applicable
+\item  ``V2'' means DWARF Version 2, published July 1993.
+\item  ``V3'' means DWARF Version 3, published December 2005.
+\item  ``V4'' means DWARF Version 4, published June 2010.
+\item  ``-'' means that a version number is not applicable
 (the section's header does not include a version).
 
-\item  "x" means that the section was not defined in that
+\item  ``x'' means that the section was not defined in that
 version of the DWARF standard.
 
 \item  The version numbers for the \addtoindex{.debug\_info} and \addtoindex{.debug\_types}
index 6ffba1d..3eaa8dd 100644 (file)
@@ -38,7 +38,9 @@ Figure \refersec{fig:encodingattributevalues}
 and following text.  
 
 A base type entry
-may have a \livelink{chap:DWATendianity}{DW\-\_AT\-\_endianity} attribute as described in 
+may have a \livelink{chap:DWATendianity}{DW\-\_AT\-\_endianity} attribute
+\addtoindexx{endianity attribute}
+as described in 
 Section \refersec{chap:dataobjectentries}. 
 If omitted, the encoding assumes the representation that
 is the default for the target architecture.
@@ -47,12 +49,15 @@ A base type entry has
 \hypertarget{chap:DWATbytesizedataobjectordatatypesize}
 either a \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} attribute
 \hypertarget{chap:DWATbitsizebasetypebitsize}
-or a \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size} attribute whose integer constant value
+or a \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size} attribute 
+\addtoindex{bit size attribute}
+whose integer constant value
 (see Section \refersec{chap:byteandbitsizes}) 
 is the amount of storage needed to hold
 a value of the type.
 
-\textit{For example, the C type int on a machine that uses 32\dash bit
+\textit{For example, the 
+\addtoindex{C} type int on a machine that uses 32\dash bit
 integers is represented by a base type entry with a name
 attribute whose value is “int”, an encoding attribute
 whose value is \livelink{chap:DWATEsigned}{DW\-\_ATE\-\_signed} and a byte size attribute whose
@@ -61,9 +66,12 @@ value is 4.}
 If the value of an object of the given type does not fully
 occupy the storage described by a byte size attribute,
 \hypertarget{chap:DWATdatabitoffsetbasetypebitlocation}
-the base type entry may also have a 
+the base type entry may also have 
+\addtoindexx{bit size attribute}
+a 
 \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size} and a
-\livelink{chap:DWATdatabitoffset}{DW\-\_AT\-\_data\-\_bit\-\_offset} attribute, both of whose values are
+\livelink{chap:DWATdatabitoffset}{DW\-\_AT\-\_data\-\_bit\-\_offset} attribute, 
+both of whose values are
 integer constant values (
 see Section \refersec{chap:staticanddynamicvaluesofattributes}). 
 The bit size
@@ -78,12 +86,19 @@ target system to locate the beginning of the storage and
 value. If this attribute is omitted a default data bit offset
 of zero is assumed.
 
-\textit{Attribute \livelink{chap:DWATdatabitoffset}{DW\-\_AT\-\_data\-\_bit\-\_offset} is new in DWARF Version 4 and
+\textit{Attribute 
+\livelink{chap:DWATdatabitoffset}{DW\-\_AT\-\_data\-\_bit\-\_offset} 
+is 
+\addtoindexx{bit offset attribute}
+new in DWARF Version 4 and
 is also used for bit field members 
 (see Section \refersec{chap:datamemberentries}). 
 It
 \hypertarget{chap:DWATbitoffsetbasetypebitlocation}
-replaces the attribute \livelink{chap:DWATbitoffset}{DW\-\_AT\-\_bit\-\_offset} when used for base
+replaces the attribute 
+\livelink{chap:DWATbitoffset}{DW\-\_AT\-\_bit\-\_offset} 
+when used for base
+\addtoindexx{bit offset attribute (V3)}
 types as defined in DWARF V3 and earlier. The earlier attribute
 is defined in a manner suitable for bit field members on
 big\dash endian architectures but which is wasteful for use on
@@ -98,14 +113,19 @@ support its use for compatibility.}
 
 \begin{myindentpara}{1cm}
 \textit{A base type entry has a \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} attribute, whose value
-(see Section 2.19) is the size in bytes of the storage unit
+(see Section \refersec{chap:staticanddynamicvaluesofattributes})
+is the size in bytes of the storage unit
 used to represent an object of the given type.}
 
 \textit{If the value of an object of the given type does not fully
 occupy the storage unit described by the byte size attribute,
-the base type entry may have a \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size} attribute and a
-\livelink{chap:DWATbitoffset}{DW\-\_AT\-\_bit\-\_offset} attribute, both of whose values (see Section
-2.19) are integers. The bit size attribute describes the actual
+the base type entry may have a 
+\livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size} attribute 
+\addtoindexx{bit size attribute (V3)}
+and a
+\livelink{chap:DWATbitoffset}{DW\-\_AT\-\_bit\-\_offset} attribute, both of whose values 
+(see Section \refersec{chap:staticanddynamicvaluesofattributes}) 
+are integers. The bit size attribute describes the actual
 size in bits used to represent a value of the given type.
 The bit offset attribute describes the offset in bits of the
 high order bit of a value of the given type from the high
@@ -163,7 +183,8 @@ 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,
-ISO/IEC 10646\dash 1:1993). For example, the C++ type char16\_t is
+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
 value is “char16\_t”, an encoding attribute whose value
 is \livelink{chap:DWATEUTF}{DW\-\_ATE\-\_UTF} and a byte size attribute whose value is 2.}
@@ -250,6 +271,7 @@ and \livelink{chap:DWATEnumericstring}{DW\-\_ATE\-\_numeric\-\_string} base type
 
 \hypertarget{chap:DWATbinaryscalebinaryscalefactorforfixedpointtype}
 For a data type with a binary scale factor, the fixed
+\addtoindexx{binary scale attribute}
 binary type entry has a \livelink{chap:DWATbinaryscale}{DW\-\_AT\-\_binary\-\_scale} attribute. The
 \livelink{chap:DWATbinaryscale}{DW\-\_AT\-\_binary\-\_scale} attribute is an integer constant value
 that represents the exponent of the base two scale factor to
@@ -316,7 +338,8 @@ string containing the name as it appears in the source program.
 
 The interpretation of this debugging information entry is
 intentionally left flexible to allow it to be interpreted
-appropriately in different languages. For example, in C and C++
+appropriately in different languages. For example, in 
+\addtoindex{C} and \addtoindex{C++}
 the language implementation can provide an unspecified type
 entry with the name “void” which can be referenced by the
 type attribute of pointer types and typedef declarations for
@@ -444,7 +467,8 @@ terms of another type may be called a type alias, a subtype,
 a constrained type and other terms. A type name declared with
 no defining details may be termed an incomplete, forward
 or hidden type. While the DWARF \livelink{chap:DWTAGtypedef}{DW\-\_TAG\-\_typedef} entry was
-originally inspired by the like named construct in C and C++,
+originally inspired by the like named construct in 
+\addtoindex{C} and \addtoindex{C++},
 it is broadly suitable for similar constructs (by whatever
 source syntax) in other languages.}
 
@@ -502,8 +526,15 @@ of storage that is normally allocated to hold an individual
 object of the 
 \hypertarget{chap:DWATbytestridearrayelementstrideofarraytype}
 indicated element type, then the array type
-entry has either a \livelink{chap:DWATbytestride}{DW\-\_AT\-\_byte\-\_stride} or a \livelink{chap:DWATbitstride}{DW\-\_AT\-\_bit\-\_stride}
-attribute, whose value 
+\addtoindexx{bit stride attribute}
+entry has either a 
+\livelink{chap:DWATbytestride}{DW\-\_AT\-\_byte\-\_stride} 
+or 
+\addtoindexx{byte stride attribute}
+a \livelink{chap:DWATbitstride}{DW\-\_AT\-\_bit\-\_stride}
+attribute, 
+\addtoindexx{bit stride attribute}
+whose value 
 (see Section \refersec{chap:staticanddynamicvaluesofattributes}) 
 is the size of each
 element of the array.
@@ -544,32 +575,40 @@ Appendix \refersec{app:fortran90example}.
 \section{ Structure, Union, Class and Interface Type Entries}
 \label{chap:structureunionclassandinterfacetypeentries}
 
-\textit{The languages C, C++, and Pascal, among others, allow the
+\textit{The languages 
+\addtoindex{C}, 
+\addtoindex{C++}, and 
+\addtoindex{Pascal}, among others, allow the
 programmer to define types that are collections of related
-components. In C and C++, these collections are called
-“structures.” In Pascal, they are called “records.”
+components. In \addtoindex{C} and \addtoindex{C++}, these collections are called
+“structures.” In \addtoindex{Pascal}, they are called “records.”
 The components may be of different types. The components are
-called “members” in C and C++, and “fields” in Pascal.}
+called “members” in \addtoindex{C} and 
+\addtoindex{C++}, and “fields” in \addtoindex{Pascal}.}
 
 \textit{The components of these collections each exist in their
 own space in computer memory. The components of a C or C++
 “union” all coexist in the same memory.}
 
-\textit{Pascal and other languages have a “discriminated union,”
+\textit{\addtoindex{Pascal} and 
+other languages have a “discriminated union,”
 also called a “variant record.” Here, selection of a
 number of alternative substructures (“variants”) is based
 on the value of a component that is not part of any of those
 substructures (the “discriminant”).}
 
-\textit{C++ and Java have the notion of "class”, which is in some
+\textit{\addtoindex{C++} and 
+\addtoindex{Java} have the notion of ``class'', which is in some
 ways similar to a structure. A class may have “member
 functions” which are subroutines that are within the scope
 of a class or structure.}
 
-\textit{The C++ notion of structure is more general than in C, being
+\textit{The \addtoindex{C++} notion of 
+structure is more general than in \addtoindex{C}, being
 equivalent to a class with minor differences. Accordingly,
-in the following discussion statements about C++ classes may
-be understood to apply to C++ structures as well.}
+in the following discussion statements about 
+\addtoindex{C++} classes may
+be understood to apply to \addtoindex{C++} structures as well.}
 
 \subsection{Structure, Union and Class Type Entries}
 \label{chap:structureunionandclasstypeentries}
@@ -627,7 +666,8 @@ need to contain an attribute for the name of the structure,
 class or union they represent if such information is already
 provided in the declaration.
 
-\textit{For C and C++, data member declarations occurring within
+\textit{For \addtoindex{C} and \addtoindex{C++}, 
+data member declarations occurring within
 the declaration of a structure, union or class type are
 considered to be “definitions” of those members, with
 the exception of “static” data members, whose definitions
@@ -667,8 +707,10 @@ facilitate DWARF space compression
 \subsection{Interface Type Entries}
 \label{chap:interfacetypeentries}
 
-\textit{The Java language defines "interface" types. An interface
-in Java is similar to a C++ or Java class with only abstract
+\textit{The \addtoindex{Java} language defines ``interface'' types. 
+An interface
+in Java is similar to a \addtoindex{C++} or 
+\addtoindex{Java} class with only abstract
 methods and constant data members.}
 
 Interface types are represented by debugging information
@@ -687,10 +729,10 @@ declarations in the source program.
 \subsection{Derived or Extended Structs, Classes and Interfaces}
 \label{chap:derivedorextendedstructsclasesandinterfaces}
 
-\textit{In C++, a class (or struct) may be ``derived from'' or be a
+\textit{In \addtoindex{C++}, a class (or struct) may be ``derived from'' or be a
 ``subclass of'' another class. In Java, an interface may ``extend''
-one or more other interfaces, and a class may "extend" another
-class and/or "implement" one or more interfaces. All of these
+one or more other interfaces, and a class may ``extend'' another
+class and/or ``implement'' one or more interfaces. All of these
 relationships may be described using the following. Note that
 in Java, the distinction between extends and implements is
 implied by the entities at the two ends of the relationship.}
@@ -741,16 +783,16 @@ struct or union.
 If 
 \hypertarget{chap:DWATvirtualityvirtualityofbaseclass}
 the class referenced by the inheritance entry serves
-as a C++ virtual base class, the inheritance entry has a
+as a \addtoindex{C++} virtual base class, the inheritance entry has a
 \livelink{chap:DWATvirtuality}{DW\-\_AT\-\_virtuality} attribute.
 
-\textit{For a C++ virtual base, the data member location attribute
+\textit{For a \addtoindex{C++} virtual base, the data member location attribute
 will usually consist of a non-trivial location description.}
 
 \subsection{Access Declarations}
 \label{chap:accessdeclarations}
 
-\textit{In C++, a derived class may contain access declarations that
+\textit{In \addtoindex{C++}, a derived class may contain access declarations that
 \addtoindex{access declaration entry}
 change the accessibility of individual class members from the
 overall accessibility specified by the inheritance declaration.
@@ -825,9 +867,10 @@ which is a \livelink{chap:flag}{flag}.
 This attribute indicates whether the data
 member was declared with the mutable storage class specifier.
 
-The 
+The beginning of a data member 
 \addtoindex{beginning of a data member} 
 is described relative to
+\addtoindexx{beginning of an object}
 the beginning of the object in which it is immediately
 contained. In general, the beginning is characterized by
 both an address and a bit offset within the byte at that
@@ -892,13 +935,17 @@ per byte.
 
 If the size of a data member is not the same as the size
 of the type given for the data member, the data member has
-either a \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} or a \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size} attribute whose
+\addtoindexx{bit size attribute}
+either a \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} 
+or a \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size} attribute whose
 integer constant value 
 (see Section \refersec{chap:staticanddynamicvaluesofattributes}) 
 is the amount
 of storage needed to hold the value of the data member.
 
-\textit{C and C++ bit fields typically require the use of the
+\textit{\addtoindex{C} and \addtoindex{C++} 
+\addtoindex{bit fields} 
+typically require the use of the
 \livelink{chap:DWATdatabitoffset}{DW\-\_AT\-\_data\-\_bit\-\_offset} and \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size} attributes.}
 
 \textit{This Standard uses the following bit numbering and direction
@@ -920,9 +967,13 @@ the low\dash order bit of the object.}
 \end{itemize}
 
 
-\textit{In either case, the bit so identified is defined as the beginning of the object.}
+\textit{In either case, the bit so identified is defined as the 
+\addtoindexx{beginning of an object}
+beginning of the object.}
 
-\textit{For example, take one possible representation of the following C structure definition in both big\dash and little\dash endian byte orders:}
+\textit{For example, take one possible representation of the following 
+\addtoindex{C} structure definition 
+in both big\dash and little\dash endian byte orders:}
 
 \begin{lstlisting}
 struct S {
@@ -1019,20 +1070,30 @@ as follows.}
 entry has the following attributes:}
 
 \begin{itemize}
-\item \textit{A \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} attribute whose value (see Section
-2.19) is the number of bytes that contain an instance of the
+\item \textit{A \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} 
+attribute whose value 
+(see Section \refersec{chap:staticanddynamicvaluesofattributes}) 
+is the number of bytes that contain an instance of the
 bit field and any padding bits.}
 
 \textit{The byte size attribute may be omitted if the size of the
 object containing the bit field can be inferred from the type
 attribute of the data member containing the bit field.}
 
-\item \textit{A \livelink{chap:DWATbitoffset}{DW\-\_AT\-\_bit\-\_offset} attribute whose value (see Section
-2.19) is the number of bits to the left of the leftmost
+\item \textit{A \livelink{chap:DWATbitoffset}{DW\-\_AT\-\_bit\-\_offset} 
+attribute 
+\addtoindexx{bit offset attribute (V3)}
+whose value 
+(see Section \refersec{chap:staticanddynamicvaluesofattributes}) 
+is the number of bits to the left of the leftmost
 (most significant) bit of the bit field value.}
 
-\item \textit{A \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size} attribute whose value (see Section
-2.19) is the number of bits occupied by the bit field value.}
+\item \textit{A \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size} 
+attribute 
+\addtoindexx{bit size attribute (V3)}
+whose value 
+(see Section \refersec{chap:staticanddynamicvaluesofattributes}) 
+is the number of bits occupied by the bit field value.}
 
 \end{itemize}
 
@@ -1128,8 +1189,10 @@ function, then that entry has a \livelink{chap:DWATobjectpointer}{DW\-\_AT\-\_ob
 whose value is a reference to the formal parameter entry
 that corresponds to the object for which the function is
 called. The name attribute of that formal parameter is defined
-by the current language (for example, this for C++ or self
-for Objective C and some other languages). That parameter
+by the current language (for example, 
+this for \addtoindex{C++} or self
+for \addtoindex{Objective C} 
+and some other languages). That parameter
 also has a \livelink{chap:DWATartificial}{DW\-\_AT\-\_artificial} attribute whose value is true.
 
 Conversely, if the member function entry describes a static
@@ -1160,7 +1223,7 @@ whose definition they represent.
 \subsection{Class Template Instantiations}
 \label{chap:classtemplateinstantiations}
 
-\textit{In C++ a class template is a generic definition of a class
+\textit{In \addtoindex{C++} a class template is a generic definition of a class
 type that may be instantiated when an instance of the class
 is declared or defined. The generic description of the
 class may include both parameterized types and parameterized
@@ -1380,10 +1443,11 @@ In a language that offers only
 one kind of enumeration declaration, this attribute is not
 required.
 
-\textit{In C or C++, the underlying type will be the appropriate
+\textit{In \addtoindex{C} or \addtoindex{C++}, 
+the underlying type will be the appropriate
 integral type determined by the compiler from the properties of
 \hypertarget{chap:DWATenumclasstypesafeenumerationdefinition}
-the enumeration literal values. A C++ type declaration written
+the enumeration literal values. A \addtoindex{C++} type declaration written
 using enum class declares a strongly typed enumeration and
 is represented using \livelink{chap:DWTAGenumerationtype}{DW\-\_TAG\-\_enumeration\-\_type} in combination
 with \livelink{chap:DWATenumclass}{DW\-\_AT\-\_enum\-\_class}.}
@@ -1413,20 +1477,29 @@ dimension of an array type, and the stride for that dimension
 is different than what would otherwise be determined, then
 \hypertarget{chap:DWATbitstrideenumerationstridedimensionofarraytype}
 the enumeration type entry has either a \livelink{chap:DWATbytestride}{DW\-\_AT\-\_byte\-\_stride}
-or \livelink{chap:DWATbitstride}{DW\-\_AT\-\_bit\-\_stride} attribute which specifies the separation
+or \livelink{chap:DWATbitstride}{DW\-\_AT\-\_bit\-\_stride} attribute 
+\addtoindexx{bit stride attribute}
+which specifies the separation
 between successive elements along the dimension as described
 in 
 Section \refersec{chap:visibilityofdeclarations}. 
-The value of the \livelink{chap:DWATbitstride}{DW\-\_AT\-\_bit\-\_stride} attribute
-is interpreted as bits and the value of the \livelink{chap:DWATbytestride}{DW\-\_AT\-\_byte\-\_stride}
+The value of the 
+\livelink{chap:DWATbitstride}{DW\-\_AT\-\_bit\-\_stride} attribute
+\addtoindexx{bit stride attribute}
+is interpreted as bits and the value of 
+\addtoindexx{byte stride attribute}
+the 
+\livelink{chap:DWATbytestride}{DW\-\_AT\-\_byte\-\_stride}
 attribute is interpreted as bytes.
 
 
 \section{Subroutine Type Entries}
 \label{chap:subroutinetypeentries}
 
-It is possible in C to declare pointers to subroutines
-that return a value of a specific type. In both C and C++,
+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++},
 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
@@ -1452,7 +1525,8 @@ arguments. These debugging information entries appear in the
 order that the corresponding argument types appear in the
 source program.
 
-In C there is a difference between the types of functions
+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.
 
@@ -1653,8 +1727,13 @@ of an array type, and the stride for that dimension is
 \hypertarget{chap:DWATbytestridesubrangestridedimensionofarraytype}
 different than what would otherwise be determined, then
 \hypertarget{chap:DWATbitstridesubrangestridedimensionofarraytype}
-the subrange type entry has either a \livelink{chap:DWATbytestride}{DW\-\_AT\-\_byte\-\_stride} or
-\livelink{chap:DWATbitstride}{DW\-\_AT\-\_bit\-\_stride} attribute which specifies the separation
+the subrange type entry has either 
+\addtoindexx{byte stride attribute}
+a 
+\livelink{chap:DWATbytestride}{DW\-\_AT\-\_byte\-\_stride} or
+\livelink{chap:DWATbitstride}{DW\-\_AT\-\_bit\-\_stride} attribute 
+\addtoindexx{bit stride attribute}
+which specifies the separation
 between successive elements along the dimension as described
 in 
 Section \refersec{chap:byteandbitsizes}.
@@ -1664,7 +1743,7 @@ Section \refersec{chap:byteandbitsizes}.
 \section{Pointer to Member Type Entries}
 \label{chap:pointertomembertypeentries}
 
-\textit{In C++, a pointer to a data or function member of a class or
+\textit{In \addtoindex{C++}, a pointer to a data or function member of a class or
 structure is a unique type.}
 
 A debugging information entry representing the type of an
@@ -1751,7 +1830,12 @@ appears in the source program.
 The file type entry has a \livelink{chap:DWATtype}{DW\-\_AT\-\_type} attribute describing
 the type of the objects contained in the file.
 
-The file type entry also has a \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} or
+The file type entry also 
+\addtoindexx{byte size}
+has 
+\addtoindexx{bit size}
+a 
+\livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} or
 \livelink{chap:DWATbitsize}{DW\-\_AT\-\_bit\-\_size} attribute, whose value 
 (see Section \refersec{chap:staticanddynamicvaluesofattributes})
 is the amount of storage need to hold a value of the file type.