All the TAG definition points are now marked with \livetarg.
authorDavid Anderson <davea42@earthlink.net>
Wed, 30 May 2012 17:58:39 +0000 (10:58 -0700)
committerDavid Anderson <davea42@earthlink.net>
Wed, 30 May 2012 17:58:39 +0000 (10:58 -0700)
dwarf5/latexdoc/dataobject.tex
dwarf5/latexdoc/generaldescription.tex
dwarf5/latexdoc/programscope.tex
dwarf5/latexdoc/typeentries.tex

index 6abb803..397540d 100644 (file)
@@ -12,7 +12,9 @@ a single declaration, such as a common block.
 
 Program variables, formal parameters and constants are
 represented by debugging information entries with the tags
-DW\_TAG\_variable, DW\_TAG\_formal\_parameter and DW\_TAG\_constant,
+\livetarg{chap:DWTAGvariable}{DW\_TAG\_variable}, 
+\livetarg{chap:DWTAGformalparameter}{DW\_TAG\_formal\_parameter} and 
+\livetarg{chap:DWTAGconstant}{DW\_TAG\_constant},
 respectively.
 
 \textit{The tag DW\_TAG\_constant is used for languages that
@@ -216,7 +218,9 @@ FIXME incomplete
 \section{Common Block Entries}
 \label{chap:commonblockentries}
 A Fortran common block may be described by a debugging
-information entry with the tag DW\_TAG\_common\_block. The
+information entry with the 
+tag \livetarg{chap:DWTAGcommonblock}{DW\_TAG\_common\_block}. 
+The
 common block entry has a DW\_AT\_name attribute whose value
 is a null-terminated string containing the common block
 name as it appears in the source program. It may also have a
@@ -236,14 +240,17 @@ set of declared objects. The namelist object itself may be used
 as a replacement for the list of names in various contexts.}
 
 A namelist is represented by a debugging information entry
-with the tag DW\_TAG\_namelist. If the namelist itself has a
+with the 
+tag \livetarg{chap:DWTAGnamelist}{DW\_TAG\_namelist}. 
+If the namelist itself has a
 name, the namelist entry has a DW\_AT\_name attribute, whose
 value is a null-terminated string containing the namelist’s
 name as it appears in the source program.
 
 Each name that is part of the namelist is represented
 by a debugging information entry with the tag
-DW\_TAG\_namelist\_item. Each such entry is a child of the
+\livetarg{chap:DWTAGnamelistitem}{DW\_TAG\_namelist\_item}. 
+Each such entry is a child of the
 namelist entry, and all of the namelist item entries for a
 given namelist are ordered as were the list of names they
 correspond to in the source program.
index 5eced84..6d30415 100644 (file)
@@ -1601,7 +1601,8 @@ A DWARF procedure is represented by any
 kind of debugging information entry that has a DW\-\_AT\-\_location
 attribute. If a suitable entry is not otherwise available,
 a DWARF procedure can be represented using a debugging
-information entry with the tag DW\-\_TAG\-\_dwarf\-\_procedure
+information entry with the 
+tag \livetarg{chap:DWTAGdwarfprocedure}{DW\-\_TAG\-\_dwarf\-\_procedure}
 together with a DW\-\_AT\-\_location attribute.  
 
 A DWARF procedure
index 303a832..ce61317 100644 (file)
@@ -21,9 +21,11 @@ compilation unit using an imported unit entry.
 \label{chap:normalandpartialcompilationunitentries}
 
 A normal compilation unit is represented by a debugging
-information entry with the tag DW\_TAG\_compile\_unit. A partial
+information entry with the 
+tag \livetarg{chap:DWTAGcompileunit}{DW\_TAG\_compile\_unit}. A partial
 compilation unit is represented by a debugging information
-entry with the tag DW\_TAG\_partial\_unit.
+entry with the 
+tag \livetarg{chap:DWTAGpartialunit}{DW\_TAG\_partial\_unit}.
 
 In a simple normal compilation, a single compilation unit with
 the tag 
@@ -236,8 +238,9 @@ of that compilation unit is not valid.
 \subsection{Imported Unit Entries}
 \label{chap:importedunitentries}
 The place where a normal or partial unit is imported is
-represented by a debugging information entry with the tag
-DW\_TAG\_imported\_unit. An imported unit entry contains a
+represented by a debugging information entry with the 
+tag \livetarg{chap:DWTAGimportedunit}{DW\_TAG\_imported\_unit}. 
+An imported unit entry contains a
 DW\_AT\_import attribute whose value is a reference to the
 normal or partial compilation unit whose declarations logically
 belong at the place of the imported unit entry.
@@ -258,7 +261,7 @@ can be used to reference the type definition from debugging
 information entries in other compilation units and type units.
 
 A type unit is represented by a debugging information entry
-with the tag DW\-\_TAG\-\_type\-\_unit
+with the tag \livetarg{chap:DWTAGtypeunit}{DW\-\_TAG\-\_type\-\_unit}
 A type unit entry owns debugging
 information entries that represent the definition of a single
 type, plus additional debugging information entries that may
@@ -314,7 +317,9 @@ Fortran 90 module may also be represented by a module entry
 has no concept of a corresponding module body).}
 
 A module is represented by a debugging information entry
-with the tag DW\_TAG\_module.  Module entries may own other
+with the 
+tag \livetarg{chap:DWTAGmodule}{DW\_TAG\_module}.  
+Module entries may own other
 debugging information entries describing program entities
 whose declaration scopes end at the end of the module itself.
 
@@ -348,14 +353,19 @@ do not accidentally clash in the global namespace when an
 application is linked together.}
 
 A namespace is represented by a debugging information entry
-with the tag DW\-\_TAG\-\_namespace. A namespace extension is
-represented by a DW\-\_TAG\-\_namespace entry with a DW\-\_AT\-\_extension
+with the 
+tag \livetarg{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace}. 
+A namespace extension is
+represented by a DW\-\_TAG\-\_namespace entry 
+with a DW\-\_AT\-\_extension
 attribute referring to the previous extension, or if there
-is no previous extension, to the original DW\-\_TAG\-\_namespace
+is no previous extension, to the original 
+DW\-\_TAG\-\_namespace
 entry. A namespace extension entry does not need to duplicate
 information in a previous extension entry of the namespace
 nor need it duplicate information in the original namespace
-entry. (Thus, for a namespace with a name, a DW\_AT\_name
+entry. (Thus, for a namespace with a name, 
+a DW\_AT\_name
 attribute need only be attached directly to the original
 DW\-\_TAG\-\_namespace entry.)
 
@@ -420,8 +430,9 @@ given another name.
 }
 
 An imported declaration is represented by one or
-more debugging information entries with the tag
-DW\_TAG\_imported\_declaration. When an overloaded entity
+more debugging information entries with the 
+tag \livetarg{chap:DWTARGimporteddeclaration}{DW\_TAG\_imported\_declaration}. 
+When an overloaded entity
 is imported, there is one imported declaration entry for
 each overloading. Each imported declaration entry has a
 DW\_AT\_import attribute, whose value is a reference to the
@@ -477,7 +488,9 @@ within a separate module or namespace.
 }
 
 An imported module declaration is represented by a debugging
-information entry with the tag DW\-\_TAG\-\_imported\-\_module. An
+information entry with the 
+tag \livetarg{chap:DWTAGimportedmodule}{DW\-\_TAG\-\_imported\-\_module}.
+An
 imported module entry contains a DW\-\_AT\-\_import attribute
 whose value is a reference to the module or namespace entry
 containing the definition and/or declaration entries for
@@ -552,10 +565,10 @@ The following tags exist to describe debugging information entries for subroutin
 points:
 
 \begin{tabular}{lp{9.0cm}}
-DW\_TAG\_subprogram & A subroutine or function. \\
+\livetarg{chap:DWTAGsubprogram}{DW\_TAG\_subprogram} & A subroutine or function. \\
 DW\_TAG\_inlined\_subroutine & A particular inlined 
   instance of a subroutine or function. \\
-DW\_TAG\_entry\_point & An alternate entry point. \\
+\livetarg{chap:DWTAGentrypoint}{DW\_TAG\_entry\_point} & An alternate entry point. \\
 \end{tabular}
 
 \subsection{General Subroutine and Entry Point Information}
@@ -727,11 +740,12 @@ parameter entries, such as type entries.}
 
 The unspecified parameters of a variable parameter list are
 represented by a debugging information entry with the tag
-DW\_TAG\_unspecified\_parameters.
+\livetarg{chap:DWTAGunspecifiedparameters}{DW\_TAG\_unspecified\_parameters}.
 
 The entry for a subroutine that includes a Fortran common block
-has a child entry with the tag 
-DW\-\_TAG\-\_common\-\_inclusion. The
+has a child entry with the 
+tag \livetarg{chap:DWTAGcommoninclusion}{DW\-\_TAG\-\_common\-\_inclusion}. 
+The
 common inclusion entry has a 
 DW\-\_AT\-\_common\-\_reference attribute
 whose value is a reference to the debugging information entry
@@ -826,7 +840,8 @@ it may validly throw.}
 If a subroutine explicitly declares that it may throw
 an exception for one or more types, each such type is
 represented by a debugging information entry with the tag
-DW\-\_TAG\-\_thrown\-\_type.  Each such entry is a child of the entry
+\livetarg{chap:DWTAGthrowntype}{DW\-\_TAG\-\_thrown\-\_type}.  
+Each such entry is a child of the entry
 representing the subroutine that may throw this type. Each
 thrown type entry contains a DW\-\_AT\-\_type attribute, whose
 value is a reference to an entry describing the type of the
@@ -850,7 +865,9 @@ types. The exceptions are:
 \begin{enumerate}[1.]
 \item Each formal parameterized type declaration appearing in the
 template definition is represented by a debugging information
-entry with the tag DW\-\_TAG\-\_template\-\_type\-\_parameter. Each
+entry with the 
+tag \livetarg{chap:DWTAGtemplatetypeparameter}{DW\-\_TAG\-\_template\-\_type\-\_parameter}. 
+Each
 such entry has a DW\-\_AT\-\_name attribute, whose value is a
 null\dash terminated string containing the name of the formal
 type parameter as it appears in the source program. The
@@ -972,8 +989,9 @@ or not a given entry is abstract.
 \label{chap:concreteinlinedinstances}
 
 Each inline expansion of a subroutine is represented
-by a debugging information entry with the tag
-DW\_TAG\_inlined\_subroutine. Each such entry should be a direct
+by a debugging information entry with the 
+tag \livetarg{chap:DWTAGinlinedsubroutine}{DW\_TAG\_inlined\_subroutine}. 
+Each such entry should be a direct
 child of the entry that represents the scope within which
 the inlining occurs.
 
@@ -1281,7 +1299,8 @@ that may contain any number of declarations. In some languages
 blocks to any depth.}
 
 A lexical block is represented by a debugging information
-entry with the tag DW\-\_TAG\-\_lexical\-\_block.
+entry with the 
+tag \livetarg{chap:DWTAGlexicalblock}{DW\-\_TAG\-\_lexical\-\_block}.
 
 The lexical block entry may have either a DW\_AT\_low\_pc and
 DW\_AT\_high\_pc pair of attributes or a DW\_AT\_ranges attribute
@@ -1311,7 +1330,9 @@ statement is usually the target of one or more ``go to''
 statements.
 
 A label is represented by a debugging information entry with
-the tag DW\_TAG\_label. The entry for a label should be owned by
+the 
+tag \livetarg{chap:DWTAGlabel}{DW\_TAG\_label}. 
+The entry for a label should be owned by
 the debugging information entry representing the scope within
 which the name of the label could be legally referenced within
 the source program.
@@ -1334,7 +1355,7 @@ variable may be referenced, unqualified by the name of the
 record variable.}
 
 A with statement is represented by a debugging information
-entry with the tag DW\-\_TAG\-\_with\-\_stmt.
+entry with the tag \livetarg{chap:DWTAGwithstmt}{DW\-\_TAG\-\_with\-\_stmt}.
 
 A with statement entry may have either a DW\_AT\_low\_pc and
 DW\_AT\_high\_pc pair of attributes or a DW\_AT\_ranges attribute
@@ -1360,8 +1381,10 @@ A catch block designates the type of the exception that it
 can handle.}
 
 A try block is represented by a debugging information entry
-with the tag DW\_TAG\_try\_block.  A catch block is represented by
-a debugging information entry with the tag DW\_TAG\_catch\_block.
+with the tag \livetarg{chap:DWTAGtryblock}{DW\_TAG\_try\_block}.  
+A catch block is represented by
+a debugging information entry with 
+the tag \livetarg{chap:DWTAGcatchblock}{DW\_TAG\_catch\_block}.
 
 Both try and catch block entries may have either a
 DW\_AT\_low\_pc and DW\_AT\_high\_pc pair of attributes or a
index 1287bad..e11932f 100644 (file)
@@ -333,16 +333,16 @@ order in the source presentation.
 \centering
 \begin{tabular}{lp{9cm}}
 Name&Meaning\\ \hline
-DW\_TAG\_const\_type &  C or C++ const qualified type \\
-DW\_TAG\_packed\_type& Pascal or Ada packed type \\
-DW\_TAG\_pointer\_type & Pointer to an object of the type being modified \\
-DW\_TAG\_reference\_type& C++ (lvalue) reference to an object of the type 
+\livetarg{chap:DWTAGconsttype}{DW\_TAG\_const\_type} &  C or C++ const qualified type \\
+\livetarg{chap:DWTAGpackedtype}{DW\_TAG\_packed\_type}& Pascal or Ada packed type \\
+\livetarg{chap:DWTAGpointertype}{DW\_TAG\_pointer\_type} & Pointer to an object of the type being modified \\
+\livetarg{chap:DWTAGreferencetype}{DW\_TAG\_reference\_type}& C++ (lvalue) reference to an object of the type 
 being modified \\
-DW\_TAG\_restrict\_type&C restrict qualified type \\
-DW\_TAG\_rvalue\_reference\_type & C++ rvalue reference to an object of the type
+\livetarg{chap:DWTAGrestrictype}{DW\_TAG\_restrict\_type}&C restrict qualified type \\
+\livetarg{chap:DWTAGrvaluereferencetype}{DW\_TAG\_rvalue\_reference\_type} & C++ rvalue reference to an object of the type
 being modified \\
-DW\_TAG\_shared\_type&UPC shared qualified type \\
-DW\_TAG\_volatile\_type&C or C++ volatile qualified type \\
+\livetarg{chap:DWTAGsharedtype}{DW\_TAG\_shared\_type}&UPC shared qualified type \\
+\livetarg{chap:DWTAGvolatiletype}{DW\_TAG\_volatile\_type}&C or C++ volatile qualified type \\
 \end{tabular}
 \caption{Type modifier tags}
 \label{fig:typemodifiertags}
@@ -381,7 +381,8 @@ volatile unsigned char * const restrict p;
 \label{chap:typedefentries}
 A named type that is defined in terms of another type
 definition is represented by a debugging information entry with
-the tag DW\_TAG\_typedef. The typedef entry has a DW\_AT\_name
+the tag \livetarg{chap:DWTAGtypedef}{DW\_TAG\_typedef}. 
+The typedef entry has a DW\_AT\_name
 attribute whose value is a null-terminated string containing
 the name of the typedef as it appears in the source program.
 
@@ -407,7 +408,8 @@ Many languages share the concept of an ``array,'' which is
 a table of components of identical type.
 
 An array type is represented by a debugging information entry
-with the tag DW\_TAG\_array\_type. If a name has been given to
+with the tag \livetarg{chap:DWTAGarraytype}{DW\_TAG\_array\_type}. 
+If a name has been given to
 the array type in the source program, then the corresponding
 array type entry has a DW\_AT\_name attribute whose value is a
 null-terminated string containing the array type name as it
@@ -514,8 +516,10 @@ be understood to apply to C++ structures as well.}
 
 
 Structure, union, and class types are represented by debugging
-information entries with the tags DW\_TAG\_structure\_type,
-DW\_TAG\_union\_type, and DW\_TAG\_class\_type,
+information entries with 
+the tags \livetarg{chap:DWTAGstructuretype}{DW\_TAG\_structure\_type},
+\livetarg{chap:DWTAGuniontype}{DW\_TAG\_union\_type}, 
+and \livetarg{chap:DWTAGclasstype}{DW\_TAG\_class\_type},
 respectively. If a name has been given to the structure,
 union, or class in the source program, then the corresponding
 structure type, union type, or class type entry has a
@@ -606,7 +610,8 @@ in Java is similar to a C++ or Java class with only abstract
 methods and constant data members.}
 
 Interface types are represented by debugging information
-entries with the tag DW\_TAG\_interface\_type.
+entries with the 
+tag \livetarg{chap:DWTAGinterfacetype}{DW\_TAG\_interface\_type}.
 
 An interface type entry has a DW\_AT\_name attribute, whose
 value is a null-terminated string containing the type name
@@ -633,7 +638,8 @@ derived, extended or implementing class or interface owns
 debugging information entries describing each of the classes
 or interfaces it is derived from, extending or implementing,
 respectively, ordered as they were in the source program. Each
-such entry has the tag DW\_TAG\_inheritance.
+such entry has the 
+tag \livetarg{chap:DWTAGinheritance}{DW\_TAG\_inheritance}.
 
 An inheritance entry has a DW\_AT\_type attribute whose value is
 a reference to the debugging information entry describing the
@@ -702,7 +708,8 @@ entities.
 Each ``friend'' declared by a structure, union or class
 type may be represented by a debugging information entry
 that is a child of the structure, union or class type entry;
-the friend entry has the tag DW\_TAG\_friend.
+the friend entry has the 
+tag \livetarg{chap:DWTAGfriend}{DW\_TAG\_friend}.
 
 A friend entry has a DW\_AT\_friend attribute, whose value is
 a reference to the debugging information entry describing
@@ -713,8 +720,9 @@ the declaration of the friend.
 \label{chap:datamemberentries}
 
 A data member (as opposed to a member function) is
-represented by a debugging information entry with the tag
-DW\_TAG\_member. The member entry for a named member has
+represented by a debugging information entry with the 
+tag \livetarg{chap:DWTAGmember}{DW\_TAG\_member}. 
+The member entry for a named member has
 a DW\_AT\_name attribute whose value is a null-terminated
 string containing the member name as it appears in the source
 program. If the member entry describes an anonymous union, the
@@ -1073,7 +1081,9 @@ for this instantiation.
 
 \item Each formal parameterized value declaration appearing in the
 template definition is represented by a debugging information
-entry with the tag DW\_TAG\_template\_value\_parameter. Each
+entry with the 
+tag \livetarg{chap:DWTAGtemplatevalueparameter}{DW\_TAG\_template\_value\_parameter}. 
+Each
 such entry may have a DW\_AT\_name attribute, whose value is
 a null\dash terminated string containing the name of the formal
 value parameter as it appears in the source program. The
@@ -1111,7 +1121,8 @@ generated artificially by the compiler.
 \label{chap:variantentries}
 
 A variant part of a structure is represented by a debugging
-information entry with the tag DW\_TAG\_variant\_part and is
+information entry with the 
+tag \livetarg{chap:DWTAGvariantpart}{DW\_TAG\_variant\_part} and is
 owned by the corresponding structure type entry.
 
 If the variant part has a discriminant, the discriminant is
@@ -1179,7 +1190,8 @@ Semantically, the condition is ‛true’ if the conditional
 variable's value matches any of the described constants,
 and the condition is ‛false’ otherwise.}
 
-The DW\_TAG\_condition debugging information entry describes a
+The \livetarg{chap:DWTAGcondition}{DW\_TAG\_condition} debugging information entry
+describes a
 logical condition that tests whether a given data item’s
 value matches one of a set of constant values. If a name
 has been given to the condition, the condition entry has a
@@ -1220,7 +1232,8 @@ type entry.}
 a fixed number of symbolic values.}
 
 An enumeration type is represented by a debugging information
-entry with the tag DW\_TAG\_enumeration\_type.
+entry with the tag 
+\livetarg{chap:DWTAGenumerationtype}{DW\_TAG\_enumeration\_type}.
 
 If a name has been given to the enumeration type in the source
 program, then the corresponding enumeration type entry has
@@ -1255,7 +1268,9 @@ is represented using DW\_TAG\_enumeration\_type in combination
 with DW\_AT\_enum\_class.}
 
 Each enumeration literal is represented by a debugging
-information entry with the tag DW\_TAG\_enumerator. Each
+information entry with the 
+tag \livetarg{chap:DWTAGenumerator}{DW\_TAG\_enumerator}. 
+Each
 such entry is a child of the enumeration type entry, and the
 enumerator entries appear in the same order as the declarations
 of the enumeration literals in the source program.
@@ -1347,7 +1362,8 @@ machine concept, not the class string as used in this document
 (except for the name attribute).
 
 A string type is represented by a debugging information entry
-with the tag DW\_TAG\_string\_type. If a name has been given to
+with the tag \livetarg{chap:DWTAGstringtype}{DW\_TAG\_string\_type}. 
+If a name has been given to
 the string type in the source program, then the corresponding
 string type entry has a DW\_AT\_name attribute whose value is
 a null\dash terminated string containing the string type name as
@@ -1379,7 +1395,8 @@ storage needed to hold a value of the string type.
 a group of values of ordinal type.}
 
 A set is represented by a debugging information entry with
-the tag DW\_TAG\_set\_type. If a name has been given to the
+the tag \livetarg{chap:DWTAGsettype}{DW\_TAG\_set\_type}. 
+If a name has been given to the
 set type, then the set type entry has a DW\_AT\_name attribute
 whose value is a null\dash terminated string containing the
 set type name as it appears in the source program.
@@ -1489,7 +1506,7 @@ structure is a unique type.}
 
 A debugging information entry representing the type of an
 object that is a pointer to a structure or class member has
-the tag DW\_TAG\_ptr\_to\_member\_type.
+the tag \livetarg{chap:DWTAGptrtomembertype}{DW\_TAG\_ptr\_to\_member\_type}.
 
 If the pointer to member type has a name, the pointer to
 member entry has a DW\_AT\_name attribute, whose value is a
@@ -1532,7 +1549,7 @@ whose address is being calculated.
 \begin{lstlisting}
     object.*mbr_ptr
 \end{lstlisting}
-
+% FIXME: object and mbr\_ptr should be distinguished from italic. See DW4.
 \textit{where mbr\_ptr has some pointer to member type, a debugger should:}
 
 \textit{1. Push the value of mbr\_ptr onto the DWARF expression stack.}
@@ -1549,7 +1566,9 @@ given in the type of mbr\_ptr.}
 files.}
 
 A file type is represented by a debugging information entry
-with the tag DW\_TAG\_file\_type. If the file type has a name,
+with the 
+\livetarg{chap:DWTAGfiletype}{tag DW\_TAG\_file\_type}. 
+If the file type has a name,
 the file type entry has a DW\_AT\_name attribute, whose value
 is a null\dash terminated string containing the type name as it
 appears in the source program.
@@ -1641,7 +1660,8 @@ see Appendix \refersec{app:aggregateexamples}.}
 
 A type named using a template alias is represented
 by a debugging information entry with the tag
-DW\-\_TAG\-\_template\-\_alias. The template alias entry has a
+\livetarg{chap:DWTAGtemplatealias}{DW\-\_TAG\-\_template\-\_alias}. 
+The template alias entry has a
 DW\-\_AT\-\_name attribute whose value is a null\dash terminated string
 containing the name of the template alias as it appears in
 the source program. The template alias entry also contains a