Working update reflecting many changes based on full
[dwarf-doc.git] / dwarf5 / latexdoc / datarepresentation.tex
1 \chapter{Data Representation}
2 \label{datarep:datarepresentation}
3
4 This section describes the binary representation of the
5 debugging information entry itself, of the attribute types
6 and of other fundamental elements described above.
7
8
9 \section{Vendor Extensibility}
10 \label{datarep:vendorextensibility}
11 \addtoindexx{vendor extensibility}
12 \addtoindexx{vendor specific extensions|see{vendor extensibility}}
13
14 To 
15 \addtoindexx{extensibility|see{vendor extensibility}}
16 reserve a portion of the DWARF name space and ranges of
17 enumeration values for use for vendor specific extensions,
18 special labels are reserved for tag names, attribute names,
19 base type encodings, location operations, language names,
20 calling conventions and call frame instructions.
21
22 The labels denoting the beginning and end of the reserved
23 \hypertarget{chap:DWXXXlohiuser}{}
24 value range for vendor specific extensions consist of the
25 appropriate prefix 
26 (\DWATlouserMARK{}\DWAThiuserMARK{}     DW\_AT,
27 \DWATElouserMARK{}\DWATEhiuserMARK{}    DW\_ATE, 
28 \DWCClouserMARK{}\DWCChiuserMARK{}      DW\_CC,
29 \DWCFAlouserMARK{}\DWCFAhiuserMARK{}    DW\_CFA 
30 \DWENDlouserMARK{}\DWENDhiuserMARK{}    DW\_END, 
31 \DWLANGlouserMARK{}\DWLANGhiuserMARK{}  DW\_LANG, 
32 \DWLNElouserMARK{}\DWLNEhiuserMARK{}    DW\_LNE, 
33 \DWMACROlouserMARK{}\DWMACROhiuserMARK{}DW\_MACRO,
34 \DWOPlouserMARK{}\DWOPhiuserMARK{}      DW\_OP or
35 \DWTAGlouserMARK{}\DWTAGhiuserMARK{}    DW\_TAG, 
36 respectively) followed by
37 \_lo\_user or \_hi\_user. 
38 Values in the  range between \textit{prefix}\_lo\_user 
39 and \textit{prefix}\_hi\_user inclusive,
40 are reserved for vendor specific extensions. Vendors may
41 use values in this range without conflicting with current or
42 future system\dash defined values. All other values are reserved
43 for use by the system.
44
45 \textit{For example, for DIE tags, the special
46 labels are \DWTAGlouserNAME{} and \DWTAGhiuserNAME.}
47
48 \textit{There may also be codes for vendor specific extensions
49 between the number of standard line number opcodes and
50 the first special line number opcode. However, since the
51 number of standard opcodes varies with the DWARF version,
52 the range for extensions is also version dependent. Thus,
53 \DWLNSlouserTARG{} and 
54 \DWLNShiuserTARG{} symbols are not defined.
55 }
56
57 Vendor defined tags, attributes, base type encodings, location
58 atoms, language names, line number actions, calling conventions
59 and call frame instructions, conventionally use the form
60 \text{prefix\_vendor\_id\_name}, where 
61 \textit{vendor\_id}\addtoindexx{vendor id} is some identifying
62 character sequence chosen so as to avoid conflicts with
63 other vendors.
64
65 To ensure that extensions added by one vendor may be safely
66 ignored by consumers that do not understand those extensions,
67 the following rules should be followed:
68 \begin{enumerate}[1. ]
69
70 \item New attributes should be added in such a way that a
71 debugger may recognize the format of a new attribute value
72 without knowing the content of that attribute value.
73
74 \item The semantics of any new attributes should not alter
75 the semantics of previously existing attributes.
76
77 \item The semantics of any new tags should not conflict with
78 the semantics of previously existing tags.
79
80 \item Do not add any new forms of attribute value.
81
82 \end{enumerate}
83
84
85 \section{Reserved Values}
86 \label{datarep:reservedvalues}
87 \subsection{Error Values}
88 \label{datarep:errorvalues}
89 \addtoindexx{reserved values!error}
90
91 As 
92 \addtoindexx{error value}
93 a convenience for consumers of DWARF information, the value
94 0 is reserved in the encodings for attribute names, attribute
95 forms, base type encodings, location operations, languages,
96 line number program opcodes, macro information entries and tag
97 names to represent an error condition or unknown value. DWARF
98 does not specify names for these reserved values, since they
99 do not represent valid encodings for the given type and should
100 not appear in DWARF debugging information.
101
102
103 \subsection{Initial Length Values}
104 \label{datarep:initiallengthvalues}
105 \addtoindexx{reserved values!initial length}
106
107 An \livetarg{datarep:initiallengthvalues}{initial length} field 
108 \addtoindexx{initial length field|see{initial length}}
109 is one of the fields that occur at the beginning 
110 of those DWARF sections that have a header
111 (\dotdebugaranges{}, 
112 \dotdebuginfo{}, 
113 \dotdebugline{} and
114 \dotdebugnames{}) or the length field
115 that occurs at the beginning of the CIE and FDE structures
116 in the \dotdebugframe{} section.
117
118 \needlines{4}
119 In an \addtoindex{initial length} field, the values \wfffffffzero through
120 \wffffffff are reserved by DWARF to indicate some form of
121 extension relative to \DWARFVersionII; such values must not
122 be interpreted as a length field. The use of one such value,
123 \xffffffff, is defined below 
124 (see Section \refersec{datarep:32bitand64bitdwarfformats}); 
125 the use of
126 the other values is reserved for possible future extensions.
127
128
129
130 \section{Relocatable, Split, Executable, Shared and Package Object Files} 
131 \label{datarep:executableobjectsandsharedobjects}
132
133 \subsection{Relocatable Objects}
134 \label{data:relocatableobjects}
135 A DWARF producer (for example, a compiler) typically generates its
136 debugging information as part of a relocatable object file.
137 Relocatable object files are then combined by a linker to form an
138 executable file. During the linking process, the linker resolves
139 (binds) symbolic references between the various object files, and
140 relocates the contents of each object file into a combined virtual
141 address space.
142
143 The DWARF debugging information is placed in several sections (see
144 Appendix \refersec{app:debugsectionrelationshipsinformative}), and 
145 requires an object file format capable of
146 representing these separate sections. There are symbolic references
147 between these sections, and also between the debugging information
148 sections and the other sections that contain the text and data of the
149 program itself. Many of these references require relocation, and the
150 producer must emit the relocation information appropriate to the
151 object file format and the target processor architecture. These
152 references include the following:
153
154 \begin{itemize}
155 \item The compilation unit header (see Section 
156 \refersec{datarep:unitheaders}) in the \dotdebuginfo{}
157 section contains a reference to the \dotdebugabbrev{} table. This
158 reference requires a relocation so that after linking, it refers to
159 that contribution to the combined \dotdebugabbrev{} section in the
160 executable file.
161
162 \item Debugging information entries may have attributes with the form
163 \DWFORMaddr{} (see Section \refersec{datarep:attributeencodings}). 
164 These attributes represent locations
165 within the virtual address space of the program, and require
166 relocation.
167
168 \item Debugging information entries may have attributes with the form
169 \DWFORMsecoffset{} (see Section \refersec{datarep:attributeencodings}). 
170 These attributes refer to
171 debugging information in other debugging information sections within
172 the object file, and must be relocated during the linking process.
173 Exception: attributes whose values are relative to a base offset given
174 by \DWATrangesbase{} do not need relocation.
175
176 \item Debugging information entries may have attributes with the form
177 \DWFORMrefone, \DWFORMreftwo, \DWFORMreffour, \DWFORMrefeight, or
178 \DWFORMrefudata{} (see Section \refersec{datarep:attributeencodings}). 
179 These attributes refer to other
180 debugging information entries within the same compilation unit, and
181 are relative to the beginning of the current compilation unit. These
182 values do not need relocation.
183
184 \item Debugging information entries may have attributes with the form
185 \DWFORMrefaddr{} (see Section \refersec{datarep:attributeencodings}). 
186 These attributes refer to
187 debugging information entries that may be outside the current
188 compilation unit. These values require both symbolic binding and
189 relocation.
190
191 \item Debugging information entries may have attributes with the form
192 \DWFORMstrp{} (see Section \refersec{datarep:attributeencodings}). 
193 These attributes refer to strings in
194 the \dotdebugstr{} section. These values require relocation.
195
196 \item Entries in the \dotdebugloc{}, \dotdebugranges{}, and \dotdebugaranges{}
197 sections contain references to locations within the virtual address
198 space of the program, and require relocation.
199
200 \item In the \dotdebugline{} section, the operand of the \DWLNEsetaddress{}
201 opcode is a reference to a location within the virtual address space
202 of the program, and requires relocation.
203
204  The \dotdebugstroffsets{} section contains a list of string offsets,
205 each of which is an offset of a string in the \dotdebugstr{} section. Each
206 of these offsets requires relocation. Depending on the implementation,
207 these relocations may be implicit (that is, the producer may not need to
208 emit any explicit relocation information for these offsets).
209 \end{itemize}
210
211 \subsection{Split DWARF Objects}
212 \label{datarep:splitdwarfobjects}
213 A DWARF producer may partition the debugging
214 information such that the majority of the debugging
215 information can remain in individual object files without
216 being processed by the linker. The first partition contains
217 debugging information that must still be processed by the linker,
218 and includes the following:
219 \begin{itemize}
220 \item
221 The line number tables, range tables, frame tables, and
222 accelerated access tables, in the usual sections:
223 \dotdebugline, \dotdebuglinestr, \dotdebugranges, \dotdebugframe,
224 \dotdebugnames{} and \dotdebugaranges,
225 respectively.
226 \needlines{4}
227 \item
228 An address table, in the \dotdebugaddr{} section. This table
229 contains all addresses and constants that require
230 link-time relocation, and items in the table can be
231 referenced indirectly from the debugging information via
232 the \DWFORMaddrx{} form, and by the \DWOPaddrx{} and
233 \DWOPconstx{} operators.
234 \item
235 A skeleton compilation unit, as described in Section
236 \refersec{chap:skeletoncompilationunitentries}, 
237 in the \dotdebuginfo{} section.
238 \item
239 An abbreviations table for the skeleton compilation unit,
240 in the \dotdebugabbrev{} section.
241 \item
242 A string table, in the \dotdebugstr{} section. The string
243 table is necessary only if the skeleton compilation unit
244 uses either indirect string form, \DWFORMstrp{} or
245 \DWFORMstrx.
246 \item
247 A string offsets table, in the \dotdebugstroffsets{}
248 section. The string offsets table is necessary only if
249 the skeleton compilation unit uses the \DWFORMstrx{} form.
250 \end{itemize}
251 The attributes contained in the skeleton compilation
252 unit can be used by a DWARF consumer to find the object file
253 or DWARF object file that contains the second partition.
254
255 The second partition contains the debugging information that
256 does not need to be processed by the linker. These sections
257 may be left in the object files and ignored by the linker
258 (that is, not combined and copied to the executable object), or
259 they may be placed by the producer in a separate DWARF object
260 file. This partition includes the following:
261 \begin{itemize}
262 \item
263 The full compilation unit, in the \dotdebuginfodwo{} section.
264 Attributes in debugging information entries may refer to
265 machine addresses indirectly using the \DWFORMaddrx{} form,
266 and location expressions may do so using the \DWOPaddrx{} and
267 \DWOPconstx{} forms. Attributes may refer to range table
268 entries with an offset relative to a base offset in the
269 range table for the compilation unit.
270
271 \item Separate type units, in the \dotdebuginfodwo{} section.
272
273 \item
274 Abbreviations table(s) for the compilation unit and type
275 units, in the \dotdebugabbrevdwo{} section.
276
277 \item Location lists, in the \dotdebuglocdwo{} section.
278
279 \item
280 A skeleton line number table (for the type units), in the
281 \dotdebuglinedwo{} section (see 
282 Section \refersec{chap:skeletoncompilationunitentries}).
283
284 \item Macro information, in the \dotdebugmacrodwo{} section.
285
286 \item A string table, in the \dotdebugstrdwo{} section.
287
288 \item A string offsets table, in the \dotdebugstroffsetsdwo{}
289 section.
290 \end{itemize}
291
292 Except where noted otherwise, all references in this document
293 to a debugging information section (for example, \dotdebuginfo),
294 applies also to the corresponding split DWARF section (for example,
295 \dotdebuginfodwo).
296
297 \subsection{Executable Objects}
298 \label{chap:executableobjects}
299 The relocated addresses in the debugging information for an
300 executable object are virtual addresses.
301
302 \subsection{Shared Objects}
303 \label{datarep:sharedobjects}
304 The relocated
305 addresses in the debugging information for a shared object
306 are offsets relative to the start of the lowest region of
307 memory loaded from that shared object.
308
309 \needlines{4}
310 \textit{This requirement makes the debugging information for
311 shared objects position independent.  Virtual addresses in a
312 shared object may be calculated by adding the offset to the
313 base address at which the object was attached. This offset
314 is available in the run\dash time linker\textquoteright s data structures.}
315
316 \subsection{DWARF Package Files}
317 \label{datarep:dwarfpackagefiles}
318 \textit{Using split DWARF objects allows the developer to compile, 
319 link, and debug an application quickly with less link-time overhead,
320 but a more convenient format is needed for saving the debug
321 information for later debugging of a deployed application. A
322 DWARF package file can be used to collect the debugging
323 information from the object (or separate DWARF object) files
324 produced during the compilation of an application.}
325
326 \textit{The package file is typically placed in the same directory as the
327 application, and is given the same name with a \doublequote{\texttt{.dwp}}
328 extension.\addtoindexx{\texttt{.dwp} file extension}}
329
330 A DWARF package file is itself an object file, using the
331 \addtoindexx{package files}
332 \addtoindexx{DWARF package files}
333 same object file format (including byte order) as the
334 corresponding application binary. It consists only of a file
335 header, section table, a number of DWARF debug information
336 sections, and two index sections.
337
338 \needlines{5}
339 Each DWARF package file contains no more than one of each of the
340 following sections, copied from a set of object or DWARF object
341 files, and combined, section by section:
342 \begin{alltt}
343     \dotdebuginfodwo
344     \dotdebugabbrevdwo
345     \dotdebuglinedwo
346     \dotdebuglocdwo
347     \dotdebugstroffsetsdwo
348     \dotdebugstrdwo
349     \dotdebugmacrodwo
350 \end{alltt}
351
352 The string table section in \dotdebugstrdwo{} contains all the
353 strings referenced from DWARF attributes using the form
354 \DWFORMstrx. Any attribute in a compilation unit or a type
355 unit using this form will refer to an entry in that unit's
356 contribution to the \dotdebugstroffsetsdwo{} section, which in turn
357 will provide the offset of a string in the \dotdebugstrdwo{}
358 section.
359
360 The DWARF package file also contains two index sections that
361 provide a fast way to locate debug information by compilation
362 unit signature (\DWATdwoid) for compilation units, or by type
363 signature for type units:
364 \begin{alltt}
365     \dotdebugcuindex
366     \dotdebugtuindex
367 \end{alltt}
368
369 \subsubsection{The Compilation Unit (CU) Index Section}
370 The \dotdebugcuindex{} section is a hashed lookup table that maps a
371 compilation unit signature to a set of contributions in the
372 various debug information sections. Each contribution is stored
373 as an offset within its corresponding section and a size.
374
375 Each compilation unit set may contain contributions from the
376 following sections:
377 \begin{alltt}
378     \dotdebuginfodwo{} (required)
379     \dotdebugabbrevdwo{} (required)
380     \dotdebuglinedwo
381     \dotdebuglocdwo
382     \dotdebugstroffsetsdwo
383     \dotdebugmacrodwo
384 \end{alltt}
385
386 \textit{Note that a set is not able to represent \dotdebugmacinfo{}
387 information from \DWARFVersionIV{} or earlier formats.}
388
389 \subsubsection{The Type Unit (TU) Index Section}
390 The \dotdebugtuindex{} section is a hashed lookup table that maps a
391 type signature to a set of offsets into the various debug
392 information sections. Each contribution is stored as an offset
393 within its corresponding section and a size.
394
395 Each type unit set may contain contributions from the following
396 sections:
397 \begin{alltt}
398     \dotdebuginfodwo{} (required) 
399     \dotdebugabbrevdwo{} (required)
400     \dotdebuglinedwo
401     \dotdebugstroffsetsdwo
402 \end{alltt}
403
404 \subsubsection{Format of the CU and TU Index Sections}
405 Both index sections have the same format, and serve to map a
406 64-bit signature to a set of contributions to the debug sections.
407 Each section begins with a header, followed by a hash table of
408 signatures, a parallel table of indexes, a table of offsets, and
409 a table of sizes. The index sections are aligned at 8-byte
410 boundaries in the file.
411
412 \needlines{6}
413 The index section header contains four unsigned 32-bit values:
414 %(using the byte order of the application binary):
415 \begin{itemize}
416 \item The \addtoindexi{version number}{version number!package index tables}
417  of the format of this index (currently \versiondotdebugcuindex)
418 \item L, the number of columns in the table of section offsets
419 \item N, the number of compilation units or type units in the index
420 \item M, the number of slots in the hash table
421 \end{itemize}
422
423 \textit{We assume that N and M will not exceed $2^{32}$.}
424
425 The size of the hash table, M, must be $2^k$ such that:
426 \hspace{0.3cm}$2^k\ \ >\ \ 3*N/2$
427
428 The hash table begins at offset 16 in the section, and consists
429 of an array of M 64-bit slots. Each slot contains a 64-bit
430 signature.
431 % (using the byte order of the application binary).
432
433 The parallel table of indices begins immediately after the hash table 
434 (at offset \mbox{16 + 8 * M} from the beginning of the section), and
435 consists of an array of M 32-bit slots,
436 % (using the byte order of the application binary), 
437 corresponding 1-1 with slots in the hash
438 table. Each entry in the parallel table contains a row index into
439 the tables of offsets and sizes.
440
441 Unused slots in the hash table have 0 in both the hash table
442 entry and the parallel table entry. While 0 is a valid hash
443 value, the row index in a used slot will always be non-zero.
444
445 Given a 64-bit compilation unit signature or a type signature S,
446 an entry in the hash table is located as follows:
447 \begin{enumerate}[1. ]
448 \item Calculate a primary hash $H = S\ \&\ MASK(k)$, where $MASK(k)$ is a
449     mask with the low-order k bits all set to 1.
450
451 \item Calculate a secondary hash $H' = (((S>>32)\ \&\ MASK(k))\ |\ 1)$.
452
453 \item If the hash table entry at index H matches the signature, use
454     that entry. If the hash table entry at index H is unused (all
455     zeroes), terminate the search: the signature is not present
456     in the table.
457
458 \item Let $H = (H + H')\ modulo\ M$. Repeat at Step 3.
459 \end{enumerate}
460
461 Because $M > N$, and H' and M are relatively prime, the search is
462 guaranteed to stop at an unused slot or find the match.
463
464 \needlines{4}
465 The table of offsets begins immediately following the parallel
466 table (at offset \mbox{16 + 12 * M} from the beginning of the section).
467 The table is a two-dimensional array of 32-bit words (using the
468 byte order of the application binary), with L columns and N+1
469 rows, in row-major order. Each row in the array is indexed
470 starting from 0. The first row provides a key to the columns:
471 each column in this row provides a section identifier for a debug
472 section, and the offsets in the same column of subsequent rows
473 refer to that section. The section identifiers are shown in
474 Table \referfol{tab:dwarfpackagefilesectionidentifierencodings}.
475
476 \begin{centering}
477 \setlength{\extrarowheight}{0.1cm}
478 \begin{longtable}{l|c|l}
479   \caption{DWARF package file section identifier \mbox{encodings}}
480   \label{tab:dwarfpackagefilesectionidentifierencodings}
481   \addtoindexx{DWARF package files!section identifier encodings} \\
482   \hline \bfseries Section identifier &\bfseries Value &\bfseries Section \\ \hline
483 \endfirsthead
484   \bfseries Section identifier &\bfseries Value &\bfseries Section\\ \hline
485 \endhead
486   \hline \emph{Continued on next page}
487 \endfoot
488   \hline
489 \endlastfoot
490 \DWSECTINFOTARG         & 1 & \dotdebuginfodwo \\
491 \textit{Reserved}       & 2 & \\
492 \DWSECTABBREVTARG       & 3 & \dotdebugabbrevdwo \\
493 \DWSECTLINETARG         & 4 & \dotdebuglinedwo \\
494 \DWSECTLOCTARG          & 5 & \dotdebuglocdwo \\
495 \DWSECTSTROFFSETSTARG   & 6 & \dotdebugstroffsetsdwo \\
496 %DWSECTMACINFO          &   & \dotdebugmacinfodwo \\
497 \DWSECTMACROTARG        & 7 & \dotdebugmacrodwo \\
498 \end{longtable}
499 \end{centering}
500
501 The offsets provided by the CU and TU index sections are the base
502 offsets for the contributions made by each CU or TU to the
503 corresponding section in the package file. Each CU and TU header
504 contains an \texttt{abbrev\_offset} field, used to find the abbreviations
505 table for that CU or TU within the contribution to the
506 \dotdebugabbrevdwo{} section for that CU or TU, and should be
507 interpreted as relative to the base offset given in the index
508 section. Likewise, offsets into \dotdebuglinedwo{} from
509 \DWATstmtlist{} attributes should be interpreted as relative to
510 the base offset for \dotdebuglinedwo{}, and offsets into other debug
511 sections obtained from DWARF attributes should also be
512 interpreted as relative to the corresponding base offset.
513
514 The table of sizes begins immediately following the table of
515 offsets, and provides the sizes of the contributions made by each
516 CU or TU to the corresponding section in the package file. Like
517 the table of offsets, it is a two-dimensional array of 32-bit
518 words, with L columns and N rows, in row-major order. Each row in
519 the array is indexed starting from 1 (row 0 of the table of
520 offsets also serves as the key for the table of sizes).
521
522 \subsection{DWARF Supplementary Object Files}
523 \label{data:dwarfsupplemetaryobjectfiles}
524 In order to minimize the size of debugging information, it is possible
525 to move duplicate debug information entries, strings and macro entries from
526 several executables or shared objects into a separate 
527 \addtoindexi{\textit{supplementary object file}}{supplementary object file} by some
528 post-linking utility; the moved entries and strings can be then referenced
529 from the debugging information of each of those executables or shared objects.
530
531 A DWARF supplementary object file is itself an object file, using the same object
532 file format, byte order, and size as the corresponding application executables
533 or shared libraries. It consists only of a file header, section table, and
534 a number of DWARF debug information sections.  Both the supplementary object file
535 and all the executables or shared objects that reference entries or strings in that
536 file must contain a \dotdebugsup{} section that establishes the relationship.
537
538 The \dotdebugsup{} section contains:
539 \begin{enumerate}[1. ]
540 \item \texttt{version} (uhalf) \\
541 \addttindexx{version}
542 A 2-byte unsigned integer representing the version of the DWARF
543 information for the compilation unit (see Appendix G). The
544 value in this field is \versiondotdebugsup.
545
546 \item \texttt{is\_supplementary} (ubyte) \\
547 \addttindexx{is\_supplementary}
548 A 1-byte unsigned integer, which contains the value 1 if it is
549 in the \addtoindex{supplementary object file} that other executables or 
550 shared objects refer to, or 0 if it is an executable or shared object 
551 referring to a supplemental object file file.
552
553 \needlines{4}
554 \item \texttt{sup\_filename} (null terminated filename string) \\
555 \addttindexx{sup\_filename}
556 If \addttindex{is\_supplementary} is 0, this contains either an absolute 
557 filename for the supplementary object file, or a filename relative to 
558 the object file containing the \dotdebugsup{} section.  
559 If \addttindex{is\_supplementary} is 1, then \addttindex{sup\_filename}
560 is not needed and must be an empty string (a single nul byte).
561
562 \needlines{4}
563 \item \texttt{sup\_checksum\_len} (unsigned LEB128) \\
564 \addttindexx{sup\_checksum\_len}
565 Length of the following \addttindex{sup\_checksum} field; 
566 his value can be 0 if no checksum is provided.
567
568
569 \item \texttt{sup\_checksum} (array of ubyte) \\
570 \addttindexx{sup\_checksum}
571 Some checksum or cryptographic hash function of the \dotdebuginfo{}, 
572 \dotdebugstr{} and \dotdebugmacro{} sections of the 
573 \addtoindex{supplementary object file}, or some unique identifier
574 which the implementation can choose to verify that the supplementary 
575 section object file matches what the debug information in the executables 
576 or shared objects expects.
577 \end{enumerate}
578
579 Debug information entries that refer to an executable's or shared
580 object's addresses must \emph{not} be moved to supplementary files (the
581 addesses will likely not be the same). Similarly,
582 entries referenced from within location expressions or using loclistptr
583 form attributes must not be moved to a supplementary object file.
584
585 Executable or shared object compilation units can use
586 \DWTAGimportedunit{} with \DWFORMrefsup{} form \DWATimport{} attribute
587 to import entries from the supplementary object file, other \DWFORMrefsup{}
588 attributes to refer to them and \DWFORMstrpsup{} form attributes to
589 refer to strings that are used by debug information of multiple
590 executables or shared objects.  Within the \addtoindex{supplementary object file}'s
591 debugging sections, form \DWFORMrefsup{} or \DWFORMstrpsup{} should
592 not be used, and all reference forms referring to some other sections
593 refer to the local sections in the supplementary object file.
594
595 In macro information, \DWMACROdefineindirectsup{} or
596 \DWMACROundefindirectsup{} opcodes can refer to strings in the 
597 \dotdebugstr{} section of the supplementary file, or \DWMACROtransparentincludesup{} 
598 can refer to \dotdebugmacro{} section entries.  Within the 
599 \dotdebugmacro{} section of a \addtoindex{supplementary object file}, 
600 \DWMACROdefineindirect{} and \DWMACROundefindirect{}
601 opcodes refer to the local \dotdebugstr{} section, not the one in
602 the executable or shared object."
603
604
605 \needlines{6}
606 \section{32-Bit and 64-Bit DWARF Formats}
607 \label{datarep:32bitand64bitdwarfformats}
608 \hypertarget{datarep:xxbitdwffmt}{}
609 \addtoindexx{32-bit DWARF format}
610 \addtoindexx{64-bit DWARF format}
611 There are two closely related file formats. In the 32\dash bit DWARF
612 format, all values that represent lengths of DWARF sections
613 and offsets relative to the beginning of DWARF sections are
614 represented using 32\dash bits. In the 64\dash bit DWARF format, all
615 values that represent lengths of DWARF sections and offsets
616 relative to the beginning of DWARF sections are represented
617 using 64\dash bits. A special convention applies to the initial
618 length field of certain DWARF sections, as well as the CIE and
619 FDE structures, so that the 32\dash bit and 64\dash bit DWARF formats
620 can coexist and be distinguished within a single linked object.
621
622 The differences between the 32\dash\   and 64\dash bit 
623 DWARF formats are
624 detailed in the following:
625 \begin{enumerate}[1. ]
626
627 \item  In the 32\dash bit DWARF format, an 
628 \addtoindex{initial length} field (see 
629 \addtoindexx{initial length!encoding}
630 Section \ref{datarep:initiallengthvalues} on page \pageref{datarep:initiallengthvalues})
631 is an unsigned 32\dash bit integer (which
632 must be less than \xfffffffzero); in the 64\dash bit DWARF format,
633 an \addtoindex{initial length} field is 96 bits in size,
634 and has two parts:
635 \begin{itemize}
636 \item The first 32\dash bits have the value \xffffffff.
637
638 \item  The following 64\dash bits contain the actual length
639 represented as an unsigned 64\dash bit integer.
640 \end{itemize}
641
642 \textit{This representation allows a DWARF consumer to dynamically
643 detect that a DWARF section contribution is using the 64\dash bit
644 format and to adapt its processing accordingly.}
645
646 \item Section offset and section length
647 \hypertarget{datarep:sectionoffsetlength}{} 
648 \addtoindexx{section length!use in headers}
649 fields that occur
650 \addtoindexx{section offset!use in headers}
651 in the headers of DWARF sections (other than initial length
652 \addtoindexx{initial length}
653 fields) are listed following. In the 32\dash bit DWARF format these
654 are 32\dash bit unsigned integer values; in the 64\dash bit DWARF format,
655 they are 64\dash bit unsigned integer values.
656
657 \begin{center}
658 \begin{tabular}{lll}
659 Section &Name & Role  \\ \hline
660 \dotdebugaranges{}   & \addttindex{debug\_info\_offset}   & offset in \dotdebuginfo{} \\
661 \dotdebugframe{}/CIE & \addttindex{CIE\_id}               & CIE distinguished value \\
662 \dotdebugframe{}/FDE & \addttindex{CIE\_pointer}          & offset in \dotdebugframe{} \\
663 \dotdebuginfo{}      & \addttindex{debug\_abbrev\_offset} & offset in \dotdebugabbrev{} \\
664 \dotdebugline{}      & \addttindex{header\_length}        & length of header itself \\
665 \dotdebugnames{}     & entry in array of CUs              & offset in \dotdebuginfo{} \\
666                      & or local TUs                       & \\
667 \end{tabular}
668 \end{center}
669
670 \needlines{4}
671 The \texttt{CIE\_id} field in a CIE structure must be 64 bits because
672 it overlays the \texttt{CIE\_pointer} in a FDE structure; this implicit
673 union must be accessed to distinguish whether a CIE or FDE is
674 present, consequently, these two fields must exactly overlay
675 each other (both offset and size).
676
677 \item Within the body of the \dotdebuginfo{}
678 section, certain forms of attribute value depend on the choice
679 of DWARF format as follows. For the 32\dash bit DWARF format,
680 the value is a 32\dash bit unsigned integer; for the 64\dash bit DWARF
681 format, the value is a 64\dash bit unsigned integer.
682 \begin{center}
683 \begin{tabular}{lp{6cm}}
684 Form             & Role  \\ \hline
685 \DWFORMlinestrp  & offset in \dotdebuglinestr \\
686 \DWFORMrefaddr   & offset in \dotdebuginfo{} \\
687 \DWFORMrefsup    & offset in \dotdebuginfo{} section of a \mbox{supplementary} object file \\
688                    \addtoindexx{supplementary object file}
689 \DWFORMsecoffset & offset in a section other than \\
690                  & \dotdebuginfo{} or \dotdebugstr{} \\
691 \DWFORMstrp      & offset in \dotdebugstr{} \\
692 \DWFORMstrpsup   & offset in \dotdebugstr{} section of a \mbox{supplementary} object file \\
693 \DWOPcallref     & offset in \dotdebuginfo{} \\
694 \end{tabular}
695 \end{center}
696
697 \needlines{5}
698 \item Within the body of the \dotdebugline{} section, certain forms of content
699 description depend on the choice of DWARF format as follows: for the
700 32-bit DWARF format, the value is a 32-bit unsigned integer; for the
701 64-bit DWARF format, the value is a 64-bit unsigned integer.
702 \begin{center}
703 \begin{tabular}{lp{6cm}}
704 Form             & Role  \\ \hline
705 \DWFORMlinestrp  & offset in \dotdebuglinestr
706 \end{tabular}
707 \end{center}
708
709 \item Within the body of the \dotdebugnames{} 
710 sections, the representation of each entry in the array of
711 compilation units (CUs) and the array of local type units
712 (TUs), which represents an offset in the 
713 \dotdebuginfo{}
714 section, depends on the DWARF format as follows: in the
715 32\dash bit DWARF format, each entry is a 32\dash bit unsigned integer;
716 in the 64\dash bit DWARF format, it is a 64\dash bit unsigned integer.
717
718 \needlines{4}
719 \item In the body of the \dotdebugstroffsets{} and \dotdebugstroffsetsdwo{}
720 sections, the size of entries in the body depend on the DWARF
721 format as follows: in the 32-bit DWARF format, entries are 32-bit
722 unsigned integer values; in the 64-bit DWARF format, they are
723 64-bit unsigned integers.
724
725 \item In the body of the \dotdebugaddr{}, \dotdebugloc{} and \dotdebugranges{}
726 sections, the contents of the address size fields depends on the
727 DWARF format as follows: in the 32-bit DWARF format, these fields
728 contain 4; in the 64-bit DWARF format these fields contain 8.
729 \end{enumerate}
730
731
732 The 32\dash bit and 64\dash bit DWARF format conventions must \emph{not} be
733 intermixed within a single compilation unit.
734
735 \textit{Attribute values and section header fields that represent
736 addresses in the target program are not affected by these
737 rules.}
738
739 A DWARF consumer that supports the 64\dash bit DWARF format must
740 support executables in which some compilation units use the
741 32\dash bit format and others use the 64\dash bit format provided that
742 the combination links correctly (that is, provided that there
743 are no link\dash time errors due to truncation or overflow). (An
744 implementation is not required to guarantee detection and
745 reporting of all such errors.)
746
747 \textit{It is expected that DWARF producing compilers will \emph{not} use
748 the 64\dash bit format \emph{by default}. In most cases, the division of
749 even very large applications into a number of executable and
750 shared objects will suffice to assure that the DWARF sections
751 within each individual linked object are less than 4 GBytes
752 in size. However, for those cases where needed, the 64\dash bit
753 format allows the unusual case to be handled as well. Even
754 in this case, it is expected that only application supplied
755 objects will need to be compiled using the 64\dash bit format;
756 separate 32\dash bit format versions of system supplied shared
757 executable libraries can still be used.}
758
759
760
761 \section{Format of Debugging Information}
762 \label{datarep:formatofdebugginginformation}
763
764 For each compilation unit compiled with a DWARF producer,
765 a contribution is made to the \dotdebuginfo{} section of
766 the object file. Each such contribution consists of a
767 compilation unit header 
768 (see Section \refersec{datarep:compilationunitheader}) 
769 followed by a
770 single \DWTAGcompileunit{} or 
771 \DWTAGpartialunit{} debugging
772 information entry, together with its children.
773
774 For each type defined in a compilation unit, a separate
775 contribution may also be made to the 
776 \dotdebuginfo{} 
777 section of the object file. Each
778 such contribution consists of a 
779 \addtoindex{type unit} header 
780 (see Section \refersec{datarep:typeunitheader}) 
781 followed by a \DWTAGtypeunit{} entry, together with
782 its children.
783
784 Each debugging information entry begins with a code that
785 represents an entry in a separate 
786 \addtoindex{abbreviations table}. This
787 code is followed directly by a series of attribute values.
788
789 The appropriate entry in the 
790 \addtoindex{abbreviations table} guides the
791 interpretation of the information contained directly in the
792 \dotdebuginfo{} section.
793
794 \needlines{4}
795 Multiple debugging information entries may share the same
796 abbreviation table entry. Each compilation unit is associated
797 with a particular abbreviation table, but multiple compilation
798 units may share the same table.
799
800 \subsection{Unit Headers}
801 \label{datarep:unitheaders}
802 Unit headers contain a field, \addttindex{unit\_type}, whose value indicates the kind of
803 compilation unit that follows. The encodings for the unit type 
804 enumeration are shown in Table \refersec{tab:unitheaderunitkindencodings}.
805
806 \needlines{6}
807 \begin{centering}
808 \setlength{\extrarowheight}{0.1cm}
809 \begin{longtable}{l|c}
810   \caption{Unit header unit type encodings}
811   \label{tab:unitheaderunitkindencodings}
812   \addtoindexx{unit header unit type encodings} \\
813   \hline \bfseries Unit header unit type encodings&\bfseries Value \\ \hline
814 \endfirsthead
815   \bfseries Unit header unit type encodings&\bfseries Value \\ \hline
816 \endhead
817   \hline \emph{Continued on next page}
818 \endfoot
819   \hline \ddag\ \textit{New in DWARF Version 5}
820 \endlastfoot
821 \DWUTcompileTARG~\ddag    &0x01 \\ 
822 \DWUTtypeTARG~\ddag       &0x02 \\ 
823 \DWUTpartialTARG~\ddag    &0x03 \\ \hline
824 \end{longtable}
825 \end{centering}
826
827 \needlines{5}
828 \subsubsection{Compilation Unit Header}
829 \label{datarep:compilationunitheader}
830 \begin{enumerate}[1. ]
831
832 \item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
833 \addttindexx{unit\_length}
834 A 4\dash byte or 12\dash byte 
835 \addtoindexx{initial length}
836 unsigned integer representing the length
837 of the \dotdebuginfo{}
838 contribution for that compilation unit,
839 not including the length field itself. In the \thirtytwobitdwarfformat,
840  this is a 4\dash byte unsigned integer (which must be less
841 than \xfffffffzero); in the \sixtyfourbitdwarfformat, this consists
842 of the 4\dash byte value \wffffffff followed by an 8\dash byte unsigned
843 integer that gives the actual length 
844 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
845
846 \item  \texttt{version} (\addtoindex{uhalf}) \\
847 \addttindexx{version}
848 A 2\dash byte unsigned integer representing the version of the
849 DWARF information for the compilation unit \addtoindexx{version number!compilation unit} 
850 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}). 
851 The value in this field is \versiondotdebuginfo.
852
853 \needlines{4}
854 \item \texttt{unit\_type} (\addtoindex{ubyte}) \\
855 \addttindexx{unit\_type}
856 A 1-byte unsigned integer identifying this unit as a compilation unit.
857 The value of this field is 
858 \DWUTcompile{} for a {normal compilation} unit or
859 \DWUTpartial{} for a {partial compilation} unit
860 (see Section \refersec{chap:normalandpartialcompilationunitentries}).
861
862 \textit{This field is new in \DWARFVersionV.}
863
864 \needlines{4}
865 \item \addttindex{debug\_abbrev\_offset} (\livelink{datarep:sectionoffsetlength}{section offset}) \\
866 \addttindexx{debug\_abbrev\_offset}
867
868 \addtoindexx{section offset!in .debug\_info header}
869 4\dash byte or 8\dash byte unsigned offset into the 
870 \dotdebugabbrev{}
871 section. This offset associates the compilation unit with a
872 particular set of debugging information entry abbreviations. In
873 the \thirtytwobitdwarfformat, this is a 4\dash byte unsigned length;
874 in the \sixtyfourbitdwarfformat, this is an 8\dash byte unsigned length
875 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
876
877 \item \texttt{address\_size} (\addtoindex{ubyte}) \\
878 \addttindexx{address\_size}
879 A 1\dash byte unsigned integer representing the size in bytes of
880 an address on the target architecture. If the system uses
881 \addtoindexx{address space!segmented}
882 segmented addressing, this value represents the size of the
883 offset portion of an address.
884
885 \end{enumerate}
886
887 \subsubsection{Type Unit Header}
888 \label{datarep:typeunitheader}
889
890 The header for the series of debugging information entries
891 contributing to the description of a type that has been
892 placed in its own \addtoindex{type unit}, within the 
893 \dotdebuginfo{} section,
894 consists of the following information:
895 \begin{enumerate}[1. ]
896
897 \item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
898 \addttindexx{unit\_length}
899 A 4\dash byte or 12\dash byte unsigned integer 
900 \addtoindexx{initial length}
901 representing the length
902 of the \dotdebuginfo{} contribution for that type unit,
903 not including the length field itself. In the \thirtytwobitdwarfformat, 
904 this is a 4\dash byte unsigned integer (which must be
905 less than \xfffffffzero); in the \sixtyfourbitdwarfformat, this
906 consists of the 4\dash byte value \wffffffff followed by an 
907 8\dash byte unsigned integer that gives the actual length
908 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
909
910 \needlines{4}
911 \item  \texttt{version} (\addtoindex{uhalf}) \\
912 \addttindexx{version}
913 A 2\dash byte unsigned integer representing the version of the
914 DWARF information for the 
915 type unit\addtoindexx{version number!type unit} 
916 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}). 
917 The value in this field is \versiondotdebuginfo.
918
919 \item \texttt{unit\_type} (\addtoindex{ubyte}) \\
920 \addttindexx{unit\_type}
921 A 1-byte unsigned integer identifying this unit as a type unit.
922 The value of this field is \DWUTtype{} for a type unit
923 (see Section \refersec{chap:typeunitentries}).
924
925 \textit{This field is new in \DWARFVersionV.}
926
927 \needlines{4}
928 \item \addttindex{debug\_abbrev\_offset} (\livelink{datarep:sectionoffsetlength}{section offset}) \\
929 \addttindexx{debug\_abbrev\_offset}
930
931 \addtoindexx{section offset!in .debug\_info header}
932 4\dash byte or 8\dash byte unsigned offset into the 
933 \dotdebugabbrev{}
934 section. This offset associates the type unit with a
935 particular set of debugging information entry abbreviations. In
936 the \thirtytwobitdwarfformat, this is a 4\dash byte unsigned length;
937 in the \sixtyfourbitdwarfformat, this is an 8\dash byte unsigned length
938 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
939
940 \needlines{4}
941 \item \texttt{address\_size} (\addtoindex{ubyte}) \\
942 \addttindexx{address\_size}
943 A 1\dash byte unsigned integer representing the size 
944 \addtoindexx{size of an address}
945 in bytes of
946 an address on the target architecture. If the system uses
947 \addtoindexx{address space!segmented}
948 segmented addressing, this value represents the size of the
949 offset portion of an address.
950
951 \item \texttt{type\_signature} (8\dash byte unsigned integer) \\
952 \addttindexx{type\_signature}
953 \addtoindexx{type signature}
954 A 64\dash bit unique signature (see Section 
955 \refersec{datarep:typesignaturecomputation})
956 of the type described in this type
957 unit.  
958
959 \textit{An attribute that refers (using 
960 \DWFORMrefsigeight{}) to
961 the primary type contained in this 
962 \addtoindex{type unit} uses this value.}
963
964 \item \texttt{type\_offset} (\livelink{datarep:sectionoffsetlength}{section offset}) \\
965 \addttindexx{type\_offset}
966 A 4\dash byte or 8\dash byte unsigned offset 
967 \addtoindexx{section offset!in .debug\_info header}
968 relative to the beginning
969 of the \addtoindex{type unit} header.
970 This offset refers to the debugging
971 information entry that describes the type. Because the type
972 may be nested inside a namespace or other structures, and may
973 contain references to other types that have not been placed in
974 separate type units, it is not necessarily either the first or
975 the only entry in the type unit. In the \thirtytwobitdwarfformat,
976 this is a 4\dash byte unsigned length; in the \sixtyfourbitdwarfformat,
977 this is an 8\dash byte unsigned length
978 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
979
980 \end{enumerate}
981
982 \subsection{Debugging Information Entry}
983 \label{datarep:debugginginformationentry}
984
985 Each debugging information entry begins with an 
986 unsigned LEB128\addtoindexx{LEB128!unsigned}
987 number containing the abbreviation code for the entry. This
988 code represents an entry within the abbreviations table
989 associated with the compilation unit containing this entry. The
990 abbreviation code is followed by a series of attribute values.
991
992 On some architectures, there are alignment constraints on
993 section boundaries. To make it easier to pad debugging
994 information sections to satisfy such constraints, the
995 abbreviation code 0 is reserved. Debugging information entries
996 consisting of only the abbreviation code 0 are considered
997 null entries.
998
999 \subsection{Abbreviations Tables}
1000 \label{datarep:abbreviationstables}
1001
1002 The abbreviations tables for all compilation units
1003 are contained in a separate object file section called
1004 \dotdebugabbrev{}.
1005 As mentioned before, multiple compilation
1006 units may share the same abbreviations table.
1007
1008 The abbreviations table for a single compilation unit consists
1009 of a series of abbreviation declarations. Each declaration
1010 specifies the tag and attributes for a particular form of
1011 debugging information entry. Each declaration begins with
1012 an unsigned LEB128\addtoindexx{LEB128!unsigned}
1013 number representing the abbreviation
1014 code itself. It is this code that appears at the beginning
1015 of a debugging information entry in the 
1016 \dotdebuginfo{}
1017 section. As described above, the abbreviation
1018 code 0 is reserved for null debugging information entries. The
1019 abbreviation code is followed by another unsigned LEB128\addtoindexx{LEB128!unsigned}
1020 number that encodes the entry\textquoteright s tag. The encodings for the
1021 tag names are given in 
1022 Table \refersec{tab:tagencodings}.
1023
1024 \begin{centering}
1025 \setlength{\extrarowheight}{0.1cm}
1026 \begin{longtable}{l|c}
1027   \hline
1028   \caption{Tag encodings} \label{tab:tagencodings} \\
1029   \hline \bfseries Tag name&\bfseries Value\\ \hline
1030 \endfirsthead
1031   \bfseries Tag name&\bfseries Value \\ \hline
1032 \endhead
1033   \hline \emph{Continued on next page}
1034 \endfoot
1035   \hline \ddag\ \textit{New in DWARF Version 5}
1036 \endlastfoot
1037 \DWTAGarraytype{} &0x01 \\
1038 \DWTAGclasstype&0x02 \\
1039 \DWTAGentrypoint&0x03 \\
1040 \DWTAGenumerationtype&0x04 \\
1041 \DWTAGformalparameter&0x05 \\
1042 \DWTAGimporteddeclaration&0x08 \\
1043 \DWTAGlabel&0x0a \\
1044 \DWTAGlexicalblock&0x0b \\
1045 \DWTAGmember&0x0d \\
1046 \DWTAGpointertype&0x0f \\
1047 \DWTAGreferencetype&0x10 \\
1048 \DWTAGcompileunit&0x11 \\
1049 \DWTAGstringtype&0x12 \\
1050 \DWTAGstructuretype&0x13 \\
1051 \DWTAGsubroutinetype&0x15 \\
1052 \DWTAGtypedef&0x16 \\
1053 \DWTAGuniontype&0x17 \\
1054 \DWTAGunspecifiedparameters&0x18  \\
1055 \DWTAGvariant&0x19  \\
1056 \DWTAGcommonblock&0x1a  \\
1057 \DWTAGcommoninclusion&0x1b  \\
1058 \DWTAGinheritance&0x1c  \\
1059 \DWTAGinlinedsubroutine&0x1d  \\
1060 \DWTAGmodule&0x1e  \\
1061 \DWTAGptrtomembertype&0x1f  \\
1062 \DWTAGsettype&0x20  \\
1063 \DWTAGsubrangetype&0x21  \\
1064 \DWTAGwithstmt&0x22  \\
1065 \DWTAGaccessdeclaration&0x23  \\
1066 \DWTAGbasetype&0x24  \\
1067 \DWTAGcatchblock&0x25  \\
1068 \DWTAGconsttype&0x26  \\
1069 \DWTAGconstant&0x27  \\
1070 \DWTAGenumerator&0x28  \\
1071 \DWTAGfiletype&0x29  \\
1072 \DWTAGfriend&0x2a  \\
1073 \DWTAGnamelist&0x2b    \\
1074 \DWTAGnamelistitem&0x2c    \\
1075 \DWTAGpackedtype&0x2d    \\
1076 \DWTAGsubprogram&0x2e    \\
1077 \DWTAGtemplatetypeparameter&0x2f    \\
1078 \DWTAGtemplatevalueparameter&0x30    \\
1079 \DWTAGthrowntype&0x31    \\
1080 \DWTAGtryblock&0x32    \\
1081 \DWTAGvariantpart&0x33    \\
1082 \DWTAGvariable&0x34    \\
1083 \DWTAGvolatiletype&0x35    \\
1084 \DWTAGdwarfprocedure&0x36     \\
1085 \DWTAGrestricttype&0x37      \\
1086 \DWTAGinterfacetype&0x38      \\
1087 \DWTAGnamespace&0x39      \\
1088 \DWTAGimportedmodule&0x3a      \\
1089 \DWTAGunspecifiedtype&0x3b      \\
1090 \DWTAGpartialunit&0x3c      \\
1091 \DWTAGimportedunit&0x3d      \\
1092 \DWTAGcondition&\xiiif      \\
1093 \DWTAGsharedtype&0x40      \\
1094 \DWTAGtypeunit & 0x41      \\
1095 \DWTAGrvaluereferencetype & 0x42      \\
1096 \DWTAGtemplatealias & 0x43      \\
1097 \DWTAGcoarraytype~\ddag & 0x44 \\
1098 \DWTAGgenericsubrange~\ddag & 0x45 \\
1099 \DWTAGdynamictype~\ddag & 0x46 \\
1100 \DWTAGatomictype~\ddag & 0x47 \\
1101 \DWTAGcallsite~\ddag & 0x48 \\
1102 \DWTAGcallsiteparameter~\ddag & 0x49 \\
1103 \DWTAGlouser&0x4080      \\
1104 \DWTAGhiuser&\xffff      \\
1105 \end{longtable}
1106 \end{centering}
1107
1108 Following the tag encoding is a 1\dash byte value that determines
1109 whether a debugging information entry using this abbreviation
1110 has child entries or not. If the value is 
1111 \DWCHILDRENyesTARG,
1112 the next physically succeeding entry of any debugging
1113 information entry using this abbreviation is the first
1114 child of that entry. If the 1\dash byte value following the
1115 abbreviation\textquoteright s tag encoding is 
1116 \DWCHILDRENnoTARG, the next
1117 physically succeeding entry of any debugging information entry
1118 using this abbreviation is a sibling of that entry. (Either
1119 the first child or sibling entries may be null entries). The
1120 encodings for the child determination byte are given in 
1121 Table \refersec{tab:childdeterminationencodings}
1122 (As mentioned in 
1123 Section \refersec{chap:relationshipofdebugginginformationentries}, 
1124 each chain of sibling entries is terminated by a null entry.)
1125
1126 \needlines{6}
1127 \begin{centering}
1128 \setlength{\extrarowheight}{0.1cm}
1129 \begin{longtable}{l|c}
1130   \caption{Child determination encodings}
1131   \label{tab:childdeterminationencodings}
1132   \addtoindexx{Child determination encodings} \\
1133   \hline \bfseries Children determination name&\bfseries Value \\ \hline
1134 \endfirsthead
1135   \bfseries Children determination name&\bfseries Value \\ \hline
1136 \endhead
1137   \hline \emph{Continued on next page}
1138 \endfoot
1139   \hline
1140 \endlastfoot
1141 \DWCHILDRENno&0x00 \\ 
1142 \DWCHILDRENyes&0x01 \\ \hline
1143 \end{longtable}
1144 \end{centering}
1145
1146 \needlines{4}
1147 Finally, the child encoding is followed by a series of
1148 attribute specifications. Each attribute specification
1149 consists of two parts. The first part is an 
1150 unsigned LEB128\addtoindexx{LEB128!unsigned}
1151 number representing the attribute\textquoteright s name. 
1152 The second part is an 
1153 unsigned LEB128\addtoindexx{LEB128!unsigned} 
1154 number representing the attribute\textquoteright s form. 
1155 The series of attribute specifications ends with an
1156 entry containing 0 for the name and 0 for the form.
1157
1158 The attribute form 
1159 \DWFORMindirectTARG{} is a special case. For
1160 attributes with this form, the attribute value itself in the
1161 \dotdebuginfo{}
1162 section begins with an unsigned
1163 LEB128 number that represents its form. This allows producers
1164 to choose forms for particular attributes 
1165 \addtoindexx{abbreviations table!dynamic forms in}
1166 dynamically,
1167 without having to add a new entry to the abbreviations table.
1168
1169 The attribute form \DWFORMimplicitconstTARG{} is another special case.
1170 For attributes with this form, the attribute specification contains 
1171 a third part, which is a signed LEB128\addtoindexx{LEB128!signed} 
1172 number. The value of this number is used as the value of the 
1173 attribute, and no value is stored in the \dotdebuginfo{} section.
1174
1175 The abbreviations for a given compilation unit end with an
1176 entry consisting of a 0 byte for the abbreviation code.
1177
1178 \textit{See 
1179 Appendix \refersec{app:compilationunitsandabbreviationstableexample} 
1180 for a depiction of the organization of the
1181 debugging information.}
1182
1183
1184 \subsection{Attribute Encodings}
1185 \label{datarep:attributeencodings}
1186
1187 The encodings for the attribute names are given in 
1188 Table \refersec{tab:attributeencodings}.
1189
1190 The attribute form governs how the value of the attribute is
1191 encoded. There are nine classes of form, listed below. Each
1192 class is a set of forms which have related representations
1193 and which are given a common interpretation according to the
1194 attribute in which the form is used.
1195
1196 Form \DWFORMsecoffsetTARG{} 
1197 is a member of more 
1198 \addtoindexx{rangelistptr class}
1199 than 
1200 \addtoindexx{macptr class}
1201 one 
1202 \addtoindexx{loclistptr class}
1203 class,
1204 \addtoindexx{lineptr class}
1205 namely 
1206 \CLASSaddrptr, 
1207 \CLASSlineptr, 
1208 \CLASSloclistptr, 
1209 \CLASSmacptr,  
1210 \CLASSrangelistptr{} or
1211 \CLASSstroffsetsptr; 
1212 the list of classes allowed by the applicable attribute in 
1213 Table \refersec{tab:attributeencodings}
1214 determines the class of the form.
1215
1216
1217 \needlines{4}
1218 Each possible form belongs to one or more of the following classes:
1219
1220 \begin{itemize}
1221 \item \livelinki{chap:classaddress}{address}{address class} \\
1222 \livetarg{datarep:classaddress}{}
1223 Represented as either:
1224 \begin{itemize}
1225 \item An object of appropriate size to hold an
1226 address on the target machine 
1227 (\DWFORMaddrTARG). 
1228 The size is encoded in the compilation unit header 
1229 (see Section \refersec{datarep:compilationunitheader}).
1230 This address is relocatable in a relocatable object file and
1231 is relocated in an executable file or shared object.
1232
1233 \item An indirect index into a table of addresses (as 
1234 described in the previous bullet) in the
1235 \dotdebugaddr{} section (\DWFORMaddrxTARG). 
1236 The representation of a \DWFORMaddrxNAME{} value is an unsigned
1237 \addtoindex{LEB128} value, which is interpreted as a zero-based 
1238 index into an array of addresses in the \dotdebugaddr{} section.
1239 The index is relative to the value of the \DWATaddrbase{} attribute 
1240 of the associated compilation unit.
1241 \end{itemize}
1242
1243 \needlines{5}
1244 \item \livelink{chap:classaddrptr}{addrptr} \\
1245 \livetarg{datarep:classaddrptr}{}
1246 This is an offset into the \dotdebugaddr{} section (\DWFORMsecoffset). It
1247 consists of an offset from the beginning of the \dotdebugaddr{} section to the
1248 beginning of the list of machine addresses information for the
1249 referencing entity. It is relocatable in
1250 a relocatable object file, and relocated in an executable or
1251 shared object. In the \thirtytwobitdwarfformat, this offset
1252 is a 4\dash byte unsigned value; in the 64\dash bit DWARF
1253 format, it is an 8\dash byte unsigned value (see Section
1254 \refersec{datarep:32bitand64bitdwarfformats}).
1255
1256 \textit{This class is new in \DWARFVersionV.}
1257
1258 \needlines{4}
1259 \item \livelink{chap:classblock}{block} \\
1260 \livetarg{datarep:classblock}{}
1261 Blocks come in four forms:
1262
1263 \begin{myindentpara}{1cm}
1264 A 1\dash byte length followed by 0 to 255 contiguous information
1265 bytes (\DWFORMblockoneTARG).
1266 \end{myindentpara}
1267
1268 \begin{myindentpara}{1cm}
1269 A 2\dash byte length followed by 0 to 65,535 contiguous information
1270 bytes (\DWFORMblocktwoTARG).
1271 \end{myindentpara}
1272
1273 \begin{myindentpara}{1cm}
1274 A 4\dash byte length followed by 0 to 4,294,967,295 contiguous
1275 information bytes (\DWFORMblockfourTARG).
1276 \end{myindentpara}
1277
1278 \begin{myindentpara}{1cm}
1279 An unsigned LEB128\addtoindexx{LEB128!unsigned}
1280 length followed by the number of bytes
1281 specified by the length (\DWFORMblockTARG).
1282 \end{myindentpara}
1283
1284 In all forms, the length is the number of information bytes
1285 that follow. The information bytes may contain any mixture
1286 of relocated (or relocatable) addresses, references to other
1287 debugging information entries or data bytes.
1288
1289 \item \livelinki{chap:classconstant}{constant}{constant class} \\
1290 \livetarg{datarep:classconstant}{}
1291 There are eight forms of constants. There are fixed length
1292 constant data forms for one-, two-, four-, eight- and sixteen-byte values
1293 (respectively, 
1294 \DWFORMdataoneTARG, 
1295 \DWFORMdatatwoTARG, 
1296 \DWFORMdatafourTARG,
1297 \DWFORMdataeightTARG{} and
1298 \DWFORMdatasixteenTARG). 
1299 There are also variable length constant
1300 data forms encoded using LEB128 numbers (see below). 
1301 Both signed (\DWFORMsdataTARG) and unsigned 
1302 (\DWFORMudataTARG) variable length constants are available.
1303 There is also an implicit constant (\DWFORMimplicitconst),
1304 whose value is provided as part of the abbreviation
1305 declaration.
1306
1307 \needlines{4}
1308 The data in \DWFORMdataone, 
1309 \DWFORMdatatwo, 
1310 \DWFORMdatafour{}, 
1311 \DWFORMdataeight{} and
1312 \DWFORMdatasixteen{} 
1313 can be anything. Depending on context, it may
1314 be a signed integer, an unsigned integer, a floating\dash point
1315 constant, or anything else. A consumer must use context to
1316 know how to interpret the bits, which if they are target
1317 machine data (such as an integer or floating point constant)
1318 will be in target machine byte\dash order.
1319
1320 \textit{If one of the \DWFORMdataTARG\textless n\textgreater 
1321 forms is used to represent a
1322 signed or unsigned integer, it can be hard for a consumer
1323 to discover the context necessary to determine which
1324 interpretation is intended. Producers are therefore strongly
1325 encouraged to use \DWFORMsdata{} or 
1326 \DWFORMudata{} for signed and
1327 unsigned integers respectively, rather than 
1328 \DWFORMdata\textless n\textgreater.}
1329
1330 \needlines{4}
1331 \item \livelinki{chap:classexprloc}{exprloc}{exprloc class} \\
1332 \livetarg{datarep:classexprloc}{}
1333 This is an unsigned LEB128\addtoindexx{LEB128!unsigned} length followed by the
1334 number of information bytes specified by the length
1335 (\DWFORMexprlocTARG). 
1336 The information bytes contain a DWARF expression 
1337 (see Section \refersec{chap:dwarfexpressions}) 
1338 or location description 
1339 (see Section \refersec{chap:locationdescriptions}).
1340
1341 \item \livelinki{chap:classflag}{flag}{flag class} \\
1342 \livetarg{datarep:classflag}{}
1343 A flag \addtoindexx{flag class}
1344 is represented explicitly as a single byte of data
1345 (\DWFORMflagTARG) or 
1346 implicitly (\DWFORMflagpresentTARG). 
1347 In the
1348 first case, if the \nolink{flag} has value zero, it indicates the
1349 absence of the attribute; if the \nolink{flag} has a non\dash zero value,
1350 it indicates the presence of the attribute. In the second
1351 case, the attribute is implicitly indicated as present, and
1352 no value is encoded in the debugging information entry itself.
1353
1354 \item \livelinki{chap:classlineptr}{lineptr}{lineptr class} \\
1355 \livetarg{datarep:classlineptr}{}
1356 This is an offset into 
1357 \addtoindexx{section offset!in class lineptr value}
1358 the 
1359 \dotdebugline{} or \dotdebuglinedwo{} section
1360 (\DWFORMsecoffset).
1361 It consists of an offset from the beginning of the 
1362 \dotdebugline{}
1363 section to the first byte of
1364 the data making up the line number list for the compilation
1365 unit. 
1366 It is relocatable in a relocatable object file, and
1367 relocated in an executable or shared object. In the 
1368 \thirtytwobitdwarfformat, this offset is a 4\dash byte unsigned value;
1369 in the \sixtyfourbitdwarfformat, it is an 8\dash byte unsigned value
1370 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
1371
1372
1373 \item \livelinki{chap:classloclistptr}{loclistptr}{loclistptr class} \\
1374 \livetarg{datarep:classloclistptr}{}
1375 This is an offset into the 
1376 \dotdebugloc{}
1377 section
1378 (\DWFORMsecoffset). 
1379 It consists of an offset from the
1380 \addtoindexx{section offset!in class loclistptr value}
1381 beginning of the 
1382 \dotdebugloc{}
1383 section to the first byte of
1384 the data making up the 
1385 \addtoindex{location list} for the compilation unit. 
1386 It is relocatable in a relocatable object file, and
1387 relocated in an executable or shared object. In the 
1388 \thirtytwobitdwarfformat, this offset is a 4\dash byte unsigned value;
1389 in the \sixtyfourbitdwarfformat, it is an 8\dash byte unsigned value
1390 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
1391
1392
1393 \item \livelinki{chap:classmacptr}{macptr}{macptr class} \\
1394 \livetarg{datarep:classmacptr}{}
1395 This is an 
1396 \addtoindexx{section offset!in class macptr value}
1397 offset into the 
1398 \dotdebugmacro{} or \dotdebugmacrodwo{} section
1399 (\DWFORMsecoffset). 
1400 It consists of an offset from the beginning of the 
1401 \dotdebugmacro{} or \dotdebugmacrodwo{} 
1402 section to the the header making up the 
1403 macro information list for the compilation unit. 
1404 It is relocatable in a relocatable object file, and
1405 relocated in an executable or shared object. In the 
1406 \thirtytwobitdwarfformat, this offset is a 4\dash byte unsigned value;
1407 in the \sixtyfourbitdwarfformat, it is an 8\dash byte unsigned value
1408 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
1409
1410 \needlines{4}
1411 \item \livelinki{chap:classrangelistptr}{rangelistptr}{rangelistptr class} \\
1412 \livetarg{datarep:classrangelistptr}{}
1413 This is an 
1414 \addtoindexx{section offset!in class rangelistptr value}
1415 offset into the \dotdebugranges{} section
1416 (\DWFORMsecoffset). 
1417 It consists of an
1418 offset from the beginning of the 
1419 \dotdebugranges{} section
1420 to the beginning of the non\dash contiguous address ranges
1421 information for the referencing entity.  
1422 It is relocatable in
1423 a relocatable object file, and relocated in an executable or
1424 shared object. In the \thirtytwobitdwarfformat, this offset
1425 is a 4\dash byte unsigned value; in the 64\dash bit DWARF
1426 format, it is an 8\dash byte unsigned value (see Section
1427 \refersec{datarep:32bitand64bitdwarfformats}).
1428 \end{itemize}
1429
1430 \textit{Because classes
1431 \CLASSaddrptr, 
1432 \CLASSlineptr, 
1433 \CLASSloclistptr, 
1434 \CLASSmacptr, 
1435 \CLASSrangelistptr{} and
1436 \CLASSstroffsetsptr{}
1437 share a common representation, it is not possible for an
1438 attribute to allow more than one of these classes}
1439
1440
1441 \begin{itemize}
1442 \item \livelinki{chap:classreference}{reference}{reference class} \\
1443 \livetarg{datarep:classreference}{}
1444 There are four types of reference.
1445
1446 The 
1447 \addtoindexx{reference class}
1448 first type of reference can identify any debugging
1449 information entry within the containing unit. 
1450 This type of
1451 reference is an 
1452 \addtoindexx{section offset!in class reference value}
1453 offset from the first byte of the compilation
1454 header for the compilation unit containing the reference. There
1455 are five forms for this type of reference. There are fixed
1456 length forms for one, two, four and eight byte offsets
1457 (respectively,
1458 \DWFORMrefnMARK 
1459 \DWFORMrefoneTARG, 
1460 \DWFORMreftwoTARG, 
1461 \DWFORMreffourTARG,
1462 and \DWFORMrefeightTARG). 
1463 There is also an unsigned variable
1464 length offset encoded form that uses 
1465 unsigned LEB128\addtoindexx{LEB128!unsigned} numbers
1466 (\DWFORMrefudataTARG). 
1467 Because this type of reference is within
1468 the containing compilation unit no relocation of the value
1469 is required.
1470
1471 The second type of reference can identify any debugging
1472 information entry within a 
1473 \dotdebuginfo{} section; in particular,
1474 it may refer to an entry in a different compilation unit
1475 from the unit containing the reference, and may refer to an
1476 entry in a different shared object.  This type of reference
1477 (\DWFORMrefaddrTARG) 
1478 is an offset from the beginning of the
1479 \dotdebuginfo{} 
1480 section of the target executable or shared object, or, for
1481 references within a \addtoindex{supplementary object file}, 
1482 an offset from the beginning of the local \dotdebuginfo{} section;
1483 it is relocatable in a relocatable object file and frequently
1484 relocated in an executable file or shared object. For
1485 references from one shared object or static executable file
1486 to another, the relocation and identification of the target
1487 object must be performed by the consumer. In the 
1488 \thirtytwobitdwarfformat, this offset is a 4\dash byte unsigned value; 
1489 in the \sixtyfourbitdwarfformat, it is an 8\dash byte
1490 unsigned value 
1491 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
1492
1493 \textit{A debugging information entry that may be referenced by
1494 another compilation unit using 
1495 \DWFORMrefaddr{} must have a global symbolic name.}
1496
1497 \textit{For a reference from one executable or shared object to
1498 another, the reference is resolved by the debugger to identify
1499 the shared object or executable and the offset into that
1500 object\textquoteright s \dotdebuginfo{}
1501 section in the same fashion as the run
1502 time loader, either when the debug information is first read,
1503 or when the reference is used.}
1504
1505 The third type of reference can identify any debugging
1506 information type entry that has been placed in its own
1507 \addtoindex{type unit}. This type of 
1508 reference (\DWFORMrefsigeightTARG) is the
1509 \addtoindexx{type signature}
1510 64\dash bit type signature 
1511 (see Section \refersec{datarep:typesignaturecomputation}) 
1512 that was computed for the type. 
1513
1514 The fourth type of reference is a reference from within the 
1515 \dotdebuginfo{} section of the executable or shared object to
1516 a debugging information entry in the \dotdebuginfo{} section of 
1517 a \addtoindex{supplementary object file}.
1518 This type of reference (\DWFORMrefsupTARG) is an offset from the 
1519 beginning of the \dotdebuginfo{} section in the supplementary 
1520 object file.
1521
1522 \textit{The use of compilation unit relative references will reduce the
1523 number of link\dash time relocations and so speed up linking. The
1524 use of the second, third and fourth type of reference allows for the
1525 sharing of information, such as types, across compilation
1526 units, while the fourth type further allows for sharing of information 
1527 across compilation units from different executables or shared objects.}
1528
1529 \textit{A reference to any kind of compilation unit identifies the
1530 debugging information entry for that unit, not the preceding
1531 header.}
1532
1533 \needlines{4}
1534 \item \livelinki{chap:classstring}{string}{string class} \\
1535 \livetarg{datarep:classstring}{}
1536 A string is a sequence of contiguous non\dash null bytes followed by
1537 one null byte. 
1538 \addtoindexx{string class}
1539 A string may be represented: 
1540 \begin{itemize}
1541 \setlength{\itemsep}{0em}
1542 \item immediately in the debugging information entry itself 
1543 (\DWFORMstringTARG), 
1544
1545 \item as an 
1546 \addtoindexx{section offset!in class string value}
1547 offset into a string table contained in
1548 the \dotdebugstr{} section of the object file (\DWFORMstrpTARG), 
1549 the \dotdebuglinestr{} section of the object file (\DWFORMlinestrpTARG),
1550 or as an offset into a string table contained in the
1551 \dotdebugstr{} section of a \addtoindex{supplementary object file} 
1552 (\DWFORMstrpsupTARG).  \DWFORMstrpsupNAME{} offsets from the \dotdebuginfo{}  
1553 section of a \addtoindex{supplementary object file}
1554 refer to the local \dotdebugstr{} section of that same file.
1555 In the \thirtytwobitdwarfformat, the representation of a 
1556 \DWFORMstrpNAME{}, \DWFORMstrpNAME{} or \DWFORMstrpsupNAME{}
1557 value is a 4\dash byte unsigned offset; in the \sixtyfourbitdwarfformat,
1558 it is an 8\dash byte unsigned offset 
1559 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
1560
1561 \item as an indirect offset into the string table using an 
1562 index into a table of offsets contained in the 
1563 \dotdebugstroffsets{} section of the object file (\DWFORMstrxTARG).
1564 The representation of a \DWFORMstrxNAME{} value is an unsigned 
1565 \addtoindex{LEB128} value, which is interpreted as a zero-based 
1566 index into an array of offsets in the \dotdebugstroffsets{} section. 
1567 The offset entries in the \dotdebugstroffsets{} section have the 
1568 same representation as \DWFORMstrp{} values.
1569 \end{itemize}
1570 Any combination of these three forms may be used within a single compilation.
1571
1572 If the \DWATuseUTFeight{}
1573 \addtoindexx{use UTF8 attribute}\addtoindexx{UTF-8} attribute is specified for the
1574 compilation, partial, skeleton or type unit entry, string values are encoded using the
1575 UTF\dash 8 (\addtoindex{Unicode} Transformation Format\dash 8) from the Universal
1576 Character Set standard (ISO/IEC 10646\dash 1:1993).
1577 \addtoindexx{ISO 10646 character set standard}
1578 Otherwise, the string representation is unspecified.
1579
1580 \textit{The \addtoindex{Unicode} Standard Version 3 is fully compatible with
1581 ISO/IEC 10646\dash 1:1993. 
1582 \addtoindexx{ISO 10646 character set standard}
1583 It contains all the same characters
1584 and encoding points as ISO/IEC 10646, as well as additional
1585 information about the characters and their use.}
1586
1587 \textit{Earlier versions of DWARF did not specify the representation
1588 of strings; for compatibility, this version also does
1589 not. However, the UTF\dash 8 representation is strongly recommended.}
1590
1591 \needlines{4}
1592 \item \livelinki{chap:classstroffsetsptr}{stroffsetsptr}{stroffsetsptr class} \\
1593 \livetarg{datarep:classstroffsetsptr}{}
1594 This is an offset into the \dotdebugstroffsets{} section 
1595 (\DWFORMsecoffset). It consists of an offset from the beginning of the 
1596 \dotdebugstroffsets{} section to the
1597 beginning of the string offsets information for the
1598 referencing entity. It is relocatable in
1599 a relocatable object file, and relocated in an executable or
1600 shared object. In the \thirtytwobitdwarfformat, this offset
1601 is a 4\dash byte unsigned value; in the 64\dash bit DWARF
1602 format, it is an 8\dash byte unsigned value (see Section
1603 \refersec{datarep:32bitand64bitdwarfformats}).
1604
1605 \textit{This class is new in \DWARFVersionV.}
1606
1607 \end{itemize}
1608
1609 In no case does an attribute use one of the classes 
1610 \CLASSaddrptr,
1611 \CLASSlineptr,
1612 \CLASSloclistptr, 
1613 \CLASSmacptr, 
1614 \CLASSrangelistptr{} or 
1615 \CLASSstroffsetsptr{}
1616 to point into either the
1617 \dotdebuginfo{} or \dotdebugstr{} section.
1618
1619 The form encodings are listed in 
1620 Table \refersec{tab:attributeformencodings}.
1621
1622
1623 \begin{centering}
1624 \setlength{\extrarowheight}{0.1cm}
1625 \begin{longtable}{l|c|l}
1626   \caption{Attribute encodings} 
1627   \label{tab:attributeencodings} 
1628   \addtoindexx{attribute encodings} \\
1629   \hline \bfseries Attribute name&\bfseries Value &\bfseries Classes \\ \hline
1630 \endfirsthead
1631   \bfseries Attribute name&\bfseries Value &\bfseries Classes\\ \hline
1632 \endhead
1633   \hline \emph{Continued on next page}
1634 \endfoot
1635   \hline \ddag\ \textit{New in DWARF Version 5}
1636 \endlastfoot
1637 \DWATsibling&0x01&\livelink{chap:classreference}{reference} 
1638             \addtoindexx{sibling attribute} \\
1639 \DWATlocation&0x02&\livelink{chap:classexprloc}{exprloc}, 
1640         \livelink{chap:classloclistptr}{loclistptr}
1641             \addtoindexx{location attribute}   \\
1642 \DWATname&0x03&\livelink{chap:classstring}{string} 
1643             \addtoindexx{name attribute} \\
1644 \DWATordering&0x09&\livelink{chap:classconstant}{constant} 
1645             \addtoindexx{ordering attribute}  \\
1646 \DWATbytesize&0x0b&\livelink{chap:classconstant}{constant}, 
1647         \livelink{chap:classexprloc}{exprloc}, 
1648         \livelink{chap:classreference}{reference}
1649             \addtoindexx{byte size attribute} \\
1650 \textit{Reserved}&0x0c\footnote{Code 0x0c is reserved to allow backward compatible support of the 
1651                                        DW\_AT\_bit\_offset \mbox{attribute} which was 
1652                                        defined in \DWARFVersionIII{} and earlier.}
1653        &\livelink{chap:classconstant}{constant}, 
1654         \livelink{chap:classexprloc}{exprloc}, 
1655         \livelink{chap:classreference}{reference}
1656             \addtoindexx{bit offset attribute (Version 3)}
1657             \addtoindexx{DW\_AT\_bit\_offset (deprecated)}  \\
1658 \DWATbitsize&0x0d&\livelink{chap:classconstant}{constant}, 
1659         \livelink{chap:classexprloc}{exprloc}, 
1660         \livelink{chap:classreference}{reference}   
1661             \addtoindexx{bit size attribute} \\
1662 \DWATstmtlist&0x10&\livelink{chap:classlineptr}{lineptr} 
1663             \addtoindexx{statement list attribute} \\
1664 \DWATlowpc&0x11&\livelink{chap:classaddress}{address} 
1665             \addtoindexx{low PC attribute}  \\
1666 \DWAThighpc&0x12&\livelink{chap:classaddress}{address}, 
1667         \livelink{chap:classconstant}{constant}
1668             \addtoindexx{high PC attribute}  \\
1669 \DWATlanguage&0x13&\livelink{chap:classconstant}{constant} 
1670             \addtoindexx{language attribute}  \\
1671 \DWATdiscr&0x15&\livelink{chap:classreference}{reference} 
1672             \addtoindexx{discriminant attribute}  \\
1673 \DWATdiscrvalue&0x16&\livelink{chap:classconstant}{constant} 
1674             \addtoindexx{discriminant value attribute}  \\
1675 \DWATvisibility&0x17&\livelink{chap:classconstant}{constant} 
1676             \addtoindexx{visibility attribute} \\
1677 \DWATimport&0x18&\livelink{chap:classreference}{reference} 
1678             \addtoindexx{import attribute}  \\
1679 \DWATstringlength&0x19&\livelink{chap:classexprloc}{exprloc}, 
1680         \livelink{chap:classloclistptr}{loclistptr}
1681             \addtoindexx{string length attribute}  \\
1682 \DWATcommonreference&0x1a&\livelink{chap:classreference}{reference} 
1683             \addtoindexx{common reference attribute}  \\
1684 \DWATcompdir&0x1b&\livelink{chap:classstring}{string} 
1685             \addtoindexx{compilation directory attribute}  \\
1686 \DWATconstvalue&0x1c&\livelink{chap:classblock}{block}, 
1687         \livelink{chap:classconstant}{constant}, 
1688         \livelink{chap:classstring}{string}
1689             \addtoindexx{constant value attribute} \\
1690 \DWATcontainingtype&0x1d&\livelink{chap:classreference}{reference} 
1691             \addtoindexx{containing type attribute} \\
1692 \DWATdefaultvalue&0x1e&\livelink{chap:classconstant}{constant}, 
1693         \livelink{chap:classreference}{reference}, 
1694         \livelink{chap:classflag}{flag}
1695             \addtoindexx{default value attribute} \\
1696 \DWATinline&0x20&\livelink{chap:classconstant}{constant} 
1697             \addtoindexx{inline attribute}  \\
1698 \DWATisoptional&0x21&\livelink{chap:classflag}{flag} 
1699             \addtoindexx{is optional attribute} \\
1700 \DWATlowerbound&0x22&\livelink{chap:classconstant}{constant}, 
1701         \livelink{chap:classexprloc}{exprloc}, 
1702         \livelink{chap:classreference}{reference}
1703             \addtoindexx{lower bound attribute}  \\
1704 \DWATproducer&0x25&\livelink{chap:classstring}{string}
1705             \addtoindexx{producer attribute}  \\
1706 \DWATprototyped&0x27&\livelink{chap:classflag}{flag}
1707             \addtoindexx{prototyped attribute}  \\
1708 \DWATreturnaddr&0x2a&\livelink{chap:classexprloc}{exprloc},
1709         \livelink{chap:classloclistptr}{loclistptr}
1710             \addtoindexx{return address attribute}  \\
1711 \DWATstartscope&0x2c&\livelink{chap:classconstant}{constant}, 
1712         \livelink{chap:classrangelistptr}{rangelistptr}
1713             \addtoindexx{start scope attribute}  \\
1714 \DWATbitstride&0x2e&\livelink{chap:classconstant}{constant},
1715         \livelink{chap:classexprloc}{exprloc}, 
1716         \livelink{chap:classreference}{reference}
1717             \addtoindexx{bit stride attribute}  \\
1718 \DWATupperbound&0x2f&\livelink{chap:classconstant}{constant},
1719         \livelink{chap:classexprloc}{exprloc}, 
1720         \livelink{chap:classreference}{reference}
1721             \addtoindexx{upper bound attribute}  \\
1722 \DWATabstractorigin&0x31&\livelink{chap:classreference}{reference} 
1723             \addtoindexx{abstract origin attribute}  \\
1724 \DWATaccessibility&0x32&\livelink{chap:classconstant}{constant} 
1725             \addtoindexx{accessibility attribute}  \\
1726 \DWATaddressclass&0x33&\livelink{chap:classconstant}{constant} 
1727             \addtoindexx{address class attribute}  \\
1728 \DWATartificial&0x34&\livelink{chap:classflag}{flag} 
1729             \addtoindexx{artificial attribute}  \\
1730 \DWATbasetypes&0x35&\livelink{chap:classreference}{reference} 
1731             \addtoindexx{base types attribute}  \\
1732 \DWATcallingconvention&0x36&\livelink{chap:classconstant}{constant} 
1733         \addtoindexx{calling convention attribute} \\
1734 \DWATcount&0x37&\livelink{chap:classconstant}{constant}, 
1735         \livelink{chap:classexprloc}{exprloc}, 
1736         \livelink{chap:classreference}{reference} 
1737             \addtoindexx{count attribute}  \\
1738 \DWATdatamemberlocation&0x38&\livelink{chap:classconstant}{constant}, 
1739         \livelink{chap:classexprloc}{exprloc}, 
1740         \livelink{chap:classloclistptr}{loclistptr} 
1741             \addtoindexx{data member attribute}  \\
1742 \DWATdeclcolumn&0x39&\livelink{chap:classconstant}{constant} 
1743             \addtoindexx{declaration column attribute}  \\
1744 \DWATdeclfile&0x3a&\livelink{chap:classconstant}{constant} 
1745             \addtoindexx{declaration file attribute}  \\
1746 \DWATdeclline&0x3b&\livelink{chap:classconstant}{constant} 
1747             \addtoindexx{declaration line attribute}  \\
1748 \DWATdeclaration&0x3c&\livelink{chap:classflag}{flag} 
1749             \addtoindexx{declaration attribute}  \\
1750 \DWATdiscrlist&0x3d&\livelink{chap:classblock}{block} 
1751             \addtoindexx{discriminant list attribute}  \\
1752 \DWATencoding&0x3e&\livelink{chap:classconstant}{constant} 
1753             \addtoindexx{encoding attribute}  \\
1754 \DWATexternal&\xiiif&\livelink{chap:classflag}{flag} 
1755             \addtoindexx{external attribute}  \\
1756 \DWATframebase&0x40&\livelink{chap:classexprloc}{exprloc}, 
1757         \livelink{chap:classloclistptr}{loclistptr} 
1758             \addtoindexx{frame base attribute}  \\
1759 \DWATfriend&0x41&\livelink{chap:classreference}{reference} 
1760             \addtoindexx{friend attribute}  \\
1761 \DWATidentifiercase&0x42&\livelink{chap:classconstant}{constant} 
1762             \addtoindexx{identifier case attribute}  \\
1763 \DWATmacroinfo\footnote{\raggedright Not used in \DWARFVersionV. 
1764                         Reserved for compatibility and coexistence
1765                         with prior DWARF versions.}
1766             &0x43&\livelink{chap:classmacptr}{macptr} 
1767             \addtoindexx{macro information attribute (legacy)!encoding}  \\
1768 \DWATnamelistitem&0x44&\livelink{chap:classreference}{reference} 
1769             \addtoindexx{name list item attribute}  \\
1770 \DWATpriority&0x45&\livelink{chap:classreference}{reference} 
1771             \addtoindexx{priority attribute}  \\
1772 \DWATsegment&0x46&\livelink{chap:classexprloc}{exprloc}, 
1773         \livelink{chap:classloclistptr}{loclistptr} 
1774             \addtoindexx{segment attribute}  \\
1775 \DWATspecification&0x47&\livelink{chap:classreference}{reference} 
1776         \addtoindexx{specification attribute}  \\
1777 \DWATstaticlink&0x48&\livelink{chap:classexprloc}{exprloc}, 
1778         \livelink{chap:classloclistptr}{loclistptr} 
1779             \addtoindexx{static link attribute}  \\
1780 \DWATtype&0x49&\livelink{chap:classreference}{reference} 
1781             \addtoindexx{type attribute}  \\
1782 \DWATuselocation&0x4a&\livelink{chap:classexprloc}{exprloc}, 
1783         \livelink{chap:classloclistptr}{loclistptr} 
1784             \addtoindexx{location list attribute}  \\
1785 \DWATvariableparameter&0x4b&\livelink{chap:classflag}{flag} 
1786             \addtoindexx{variable parameter attribute}  \\
1787 \DWATvirtuality&0x4c&\livelink{chap:classconstant}{constant} 
1788             \addtoindexx{virtuality attribute}  \\
1789 \DWATvtableelemlocation&0x4d&\livelink{chap:classexprloc}{exprloc}, 
1790         \livelink{chap:classloclistptr}{loclistptr} 
1791             \addtoindexx{vtable element location attribute}  \\
1792 \DWATallocated&0x4e&\livelink{chap:classconstant}{constant}, 
1793         \livelink{chap:classexprloc}{exprloc}, 
1794         \livelink{chap:classreference}{reference} 
1795             \addtoindexx{allocated attribute}  \\
1796 \DWATassociated&0x4f&\livelink{chap:classconstant}{constant}, 
1797         \livelink{chap:classexprloc}{exprloc}, 
1798         \livelink{chap:classreference}{reference} 
1799             \addtoindexx{associated attribute}  \\
1800 \DWATdatalocation&0x50&\livelink{chap:classexprloc}{exprloc} 
1801         \addtoindexx{data location attribute}  \\
1802 \DWATbytestride&0x51&\livelink{chap:classconstant}{constant}, 
1803         \livelink{chap:classexprloc}{exprloc}, 
1804         \livelink{chap:classreference}{reference} 
1805             \addtoindexx{byte stride attribute}  \\
1806 \DWATentrypc&0x52&\livelink{chap:classaddress}{address}, 
1807         \livelink{chap:classconstant}{constant} 
1808             \addtoindexx{entry pc attribute}  \\
1809 \DWATuseUTFeight&0x53&\livelink{chap:classflag}{flag} 
1810             \addtoindexx{use UTF8 attribute}\addtoindexx{UTF-8}  \\
1811 \DWATextension&0x54&\livelink{chap:classreference}{reference} 
1812             \addtoindexx{extension attribute}  \\
1813 \DWATranges&0x55&\livelink{chap:classrangelistptr}{rangelistptr} 
1814             \addtoindexx{ranges attribute}  \\
1815 \DWATtrampoline&0x56&\livelink{chap:classaddress}{address}, 
1816         \livelink{chap:classflag}{flag}, 
1817         \livelink{chap:classreference}{reference}, 
1818         \livelink{chap:classstring}{string} 
1819             \addtoindexx{trampoline attribute}  \\
1820 \DWATcallcolumn&0x57&\livelink{chap:classconstant}{constant} 
1821             \addtoindexx{call column attribute}  \\
1822 \DWATcallfile&0x58&\livelink{chap:classconstant}{constant} 
1823             \addtoindexx{call file attribute}  \\
1824 \DWATcallline&0x59&\livelink{chap:classconstant}{constant} 
1825             \addtoindexx{call line attribute}  \\
1826 \DWATdescription&0x5a&\livelink{chap:classstring}{string} 
1827             \addtoindexx{description attribute}  \\
1828 \DWATbinaryscale&0x5b&\livelink{chap:classconstant}{constant} 
1829             \addtoindexx{binary scale attribute}  \\
1830 \DWATdecimalscale&0x5c&\livelink{chap:classconstant}{constant} 
1831             \addtoindexx{decimal scale attribute}  \\
1832 \DWATsmall{} &0x5d&\livelink{chap:classreference}{reference} 
1833             \addtoindexx{small attribute}  \\
1834 \DWATdecimalsign&0x5e&\livelink{chap:classconstant}{constant} 
1835             \addtoindexx{decimal scale attribute}  \\
1836 \DWATdigitcount&0x5f&\livelink{chap:classconstant}{constant} 
1837             \addtoindexx{digit count attribute}  \\
1838 \DWATpicturestring&0x60&\livelink{chap:classstring}{string} 
1839             \addtoindexx{picture string attribute}  \\
1840 \DWATmutable&0x61&\livelink{chap:classflag}{flag} 
1841             \addtoindexx{mutable attribute}  \\
1842 \DWATthreadsscaled&0x62&\livelink{chap:classflag}{flag} 
1843             \addtoindexx{thread scaled attribute}  \\
1844 \DWATexplicit&0x63&\livelink{chap:classflag}{flag} 
1845             \addtoindexx{explicit attribute}  \\
1846 \DWATobjectpointer&0x64&\livelink{chap:classreference}{reference} 
1847             \addtoindexx{object pointer attribute}  \\
1848 \DWATendianity&0x65&\livelink{chap:classconstant}{constant} 
1849             \addtoindexx{endianity attribute}  \\
1850 \DWATelemental&0x66&\livelink{chap:classflag}{flag} 
1851             \addtoindexx{elemental attribute}  \\
1852 \DWATpure&0x67&\livelink{chap:classflag}{flag} 
1853             \addtoindexx{pure attribute}  \\
1854 \DWATrecursive&0x68&\livelink{chap:classflag}{flag} 
1855             \addtoindexx{recursive attribute}  \\
1856 \DWATsignature{} &0x69&\livelink{chap:classreference}{reference} 
1857             \addtoindexx{signature attribute}  \\ 
1858 \DWATmainsubprogram{} &0x6a&\livelink{chap:classflag}{flag} 
1859             \addtoindexx{main subprogram attribute}  \\
1860 \DWATdatabitoffset{} &0x6b&\livelink{chap:classconstant}{constant} 
1861             \addtoindexx{data bit offset attribute}  \\
1862 \DWATconstexpr{} &0x6c&\livelink{chap:classflag}{flag} 
1863             \addtoindexx{constant expression attribute}  \\
1864 \DWATenumclass{} &0x6d&\livelink{chap:classflag}{flag} 
1865             \addtoindexx{enumeration class attribute}  \\
1866 \DWATlinkagename{} &0x6e&\livelink{chap:classstring}{string} 
1867             \addtoindexx{linkage name attribute}  \\
1868 \DWATstringlengthbitsize{}~\ddag&0x6f&
1869                 \livelink{chap:classconstant}{constant}
1870             \addtoindexx{string length attribute!size of length}  \\
1871 \DWATstringlengthbytesize{}~\ddag&0x70&
1872                 \livelink{chap:classconstant}{constant}
1873             \addtoindexx{string length attribute!size of length}  \\
1874 \DWATrank~\ddag&0x71&
1875         \livelink{chap:classconstant}{constant},
1876         \livelink{chap:classexprloc}{exprloc}
1877             \addtoindexx{rank attribute}  \\
1878 \DWATstroffsetsbase~\ddag&0x72&
1879                 \livelinki{chap:classstring}{stroffsetsptr}{stroffsetsptr class}
1880             \addtoindexx{string offsets base!encoding}  \\
1881 \DWATaddrbase~\ddag &0x73&
1882                 \livelinki{chap:classaddrptr}{addrptr}{addrptr class}
1883             \addtoindexx{address table base!encoding} \\
1884 \DWATrangesbase~\ddag&0x74&
1885                 \livelinki{chap:classrangelistptr}{rangelistptr}{rangelistptr class}
1886             \addtoindexx{ranges base!encoding} \\
1887 \DWATdwoid~\ddag &0x75&
1888                 \livelink{chap:classconstant}{constant}
1889             \addtoindexx{split DWARF object id!encoding} \\
1890 \DWATdwoname~\ddag &0x76&
1891                 \livelink{chap:classstring}{string}
1892             \addtoindexx{split DWARF object file name!encoding} \\
1893 \DWATreference~\ddag &0x77&
1894         \livelink{chap:classflag}{flag} \\
1895 \DWATrvaluereference~\ddag &0x78&
1896         \livelink{chap:classflag}{flag} \\
1897 \DWATmacros~\ddag &0x79&\livelink{chap:classmacptr}{macptr} 
1898         \addtoindexx{macro information attribute}  \\
1899 \DWATcallallcalls~\ddag &0x7a&\CLASSflag
1900         \addtoindexx{all calls summary attribute} \\
1901 \DWATcallallsourcecalls~\ddag &0x7b &\CLASSflag
1902         \addtoindexx{all source calls summary attribute} \\
1903 \DWATcallalltailcalls~\ddag &0x7c&\CLASSflag
1904         \addtoindexx{all tail calls summary attribute} \\
1905 \DWATcallreturnpc~\ddag &0x7d &\CLASSaddress
1906         \addtoindexx{call return pc attribute} \\
1907 \DWATcallvalue~\ddag &0x7e &\CLASSexprloc
1908         \addtoindexx{call value attribute} \\
1909 \DWATcallorigin~\ddag &0x7f &\CLASSexprloc
1910         \addtoindexx{call origin attribute} \\
1911 \DWATcallparameter~\ddag &0x80 &\CLASSreference
1912         \addtoindexx{call parameter attribute} \\
1913 \DWATcallpc~\ddag &0x81 &\CLASSaddress
1914         \addtoindexx{call pc attribute} \\
1915 \DWATcalltailcall~\ddag &0x82 &\CLASSflag
1916         \addtoindexx{call tail call attribute} \\
1917 \DWATcalltarget~\ddag &0x83 &\CLASSexprloc
1918         \addtoindexx{call target attribute} \\
1919 \DWATcalltargetclobbered~\ddag &0x84 &\CLASSexprloc
1920         \addtoindexx{call target clobbered attribute} \\
1921 \DWATcalldatalocation~\ddag &0x85 &\CLASSexprloc
1922         \addtoindexx{call data location attribute} \\
1923 \DWATcalldatavalue~\ddag &0x86 &\CLASSexprloc
1924         \addtoindexx{call data value attribute} \\
1925 \DWATnoreturn~\ddag &0x87 &\CLASSflag 
1926         \addtoindexx{noreturn attribute} \\
1927 \DWATalignment~\ddag &0x88 &\CLASSconstant 
1928         \addtoindexx{alignment attribute} \\
1929 \DWATexportsymbols~\ddag &0x89 &\CLASSflag
1930         \addtoindexx{export symbols attribute} \\
1931 \DWATdeleted~\ddag &0x8a &\CLASSflag \addtoindexx{deleted attribute} \\
1932 \DWATdefaulted~\ddag &0x8b &\CLASSconstant \addtoindexx{defaulted attribute} \\
1933 \DWATlouser&0x2000 & --- \addtoindexx{low user attribute encoding}  \\
1934 \DWAThiuser&\xiiifff& --- \addtoindexx{high user attribute encoding}  \\
1935
1936 \end{longtable} 
1937 \end{centering}
1938
1939 \needlines{8}
1940 \begin{centering}
1941 \setlength{\extrarowheight}{0.1cm}
1942 \begin{longtable}{l|c|l}
1943   \caption{Attribute form encodings} \label{tab:attributeformencodings} \\
1944   \hline \bfseries Form name&\bfseries Value &\bfseries Classes \\ \hline
1945 \endfirsthead
1946   \bfseries Form name&\bfseries Value &\bfseries Classes\\ \hline
1947 \endhead
1948   \hline \emph{Continued on next page}
1949 \endfoot
1950   \hline \ddag\ \textit{New in DWARF Version 5}
1951 \endlastfoot
1952
1953 \DWFORMaddr &0x01&\livelink{chap:classaddress}{address}  \\
1954 \textit{Reserved} &0x02& \\
1955 \DWFORMblocktwo &0x03&\livelink{chap:classblock}{block} \\
1956 \DWFORMblockfour &0x04&\livelink{chap:classblock}{block}  \\
1957 \DWFORMdatatwo &0x05&\livelink{chap:classconstant}{constant} \\
1958 \DWFORMdatafour &0x06&\livelink{chap:classconstant}{constant} \\
1959 \DWFORMdataeight &0x07&\livelink{chap:classconstant}{constant} \\
1960 \DWFORMstring&0x08&\livelink{chap:classstring}{string} \\
1961 \DWFORMblock&0x09&\livelink{chap:classblock}{block} \\
1962 \DWFORMblockone &0x0a&\livelink{chap:classblock}{block} \\
1963 \DWFORMdataone &0x0b&\livelink{chap:classconstant}{constant} \\
1964 \DWFORMflag&0x0c&\livelink{chap:classflag}{flag} \\
1965 \DWFORMsdata&0x0d&\livelink{chap:classconstant}{constant}    \\
1966 \DWFORMstrp&0x0e&\livelink{chap:classstring}{string}         \\
1967 \DWFORMudata&0x0f&\livelink{chap:classconstant}{constant}         \\
1968 \DWFORMrefaddr&0x10&\livelink{chap:classreference}{reference}         \\
1969 \DWFORMrefone&0x11&\livelink{chap:classreference}{reference}          \\
1970 \DWFORMreftwo&0x12&\livelink{chap:classreference}{reference}         \\
1971 \DWFORMreffour&0x13&\livelink{chap:classreference}{reference}         \\
1972 \DWFORMrefeight&0x14&\livelink{chap:classreference}{reference} \\
1973 \DWFORMrefudata&0x15&\livelink{chap:classreference}{reference}  \\
1974 \DWFORMindirect&0x16&(see Section \refersec{datarep:abbreviationstables}) \\
1975 \DWFORMsecoffset{} &0x17& \CLASSaddrptr, \CLASSlineptr, \CLASSloclistptr, \\
1976                    &    & \CLASSmacptr, \CLASSrangelistptr, \CLASSstroffsetsptr \\
1977 \DWFORMexprloc{} &0x18&\livelink{chap:classexprloc}{exprloc} \\
1978 \DWFORMflagpresent{} &0x19&\livelink{chap:classflag}{flag} \\
1979 \DWFORMstrx{} \ddag &0x1a&\livelink{chap:classstring}{string} \\
1980 \DWFORMaddrx{} \ddag &0x1b&\livelink{chap:classaddress}{address} \\
1981 \DWFORMrefsup{}~\ddag &0x1c &\livelink{chap:classreference}{reference} \\
1982 \DWFORMstrpsup{}~\ddag &0x1d &\livelink{chap:classstring}{string} \\
1983 \DWFORMdatasixteen~\ddag &0x1e &\CLASSconstant \\
1984 \DWFORMlinestrp~\ddag &0x1f &\CLASSstring \\
1985 \DWFORMrefsigeight &0x20 &\livelink{chap:classreference}{reference} \\
1986 \DWFORMimplicitconst~\ddag &0x21 &\CLASSconstant \\
1987 \end{longtable}
1988 \end{centering}
1989
1990
1991 \needlines{6}
1992 \section{Variable Length Data}
1993 \label{datarep:variablelengthdata}
1994 \addtoindexx{variable length data|see {LEB128}}
1995 Integers may be 
1996 \addtoindexx{Little Endian Base 128|see{LEB128}}
1997 encoded using \doublequote{Little Endian Base 128}
1998 \addtoindexx{little-endian encoding|see{endian attribute}}
1999 (LEB128) numbers. 
2000 \addtoindexx{LEB128}
2001 LEB128 is a scheme for encoding integers
2002 densely that exploits the assumption that most integers are
2003 small in magnitude.
2004
2005 \textit{This encoding is equally suitable whether the target machine
2006 architecture represents data in big\dash\ endian or little\dash endian
2007 order. It is \doublequote{little\dash endian} only in the sense that it
2008 avoids using space to represent the \doublequote{big} end of an
2009 unsigned integer, when the big end is all zeroes or sign
2010 extension bits.}
2011
2012 Unsigned LEB128\addtoindexx{LEB128!unsigned} (\addtoindex{ULEB128}) 
2013 numbers are encoded as follows:
2014 \addtoindexx{LEB128!unsigned, encoding as}
2015 start at the low order end of an unsigned integer and chop
2016 it into 7\dash bit chunks. Place each chunk into the low order 7
2017 bits of a byte. Typically, several of the high order bytes
2018 will be zero; discard them. Emit the remaining bytes in a
2019 stream, starting with the low order byte; set the high order
2020 bit on each byte except the last emitted byte. The high bit
2021 of zero on the last byte indicates to the decoder that it
2022 has encountered the last byte.
2023
2024 The integer zero is a special case, consisting of a single
2025 zero byte.
2026
2027 Table \refersec{tab:examplesofunsignedleb128encodings}
2028 gives some examples of unsigned LEB128\addtoindexx{LEB128!unsigned}
2029 numbers. The
2030 0x80 in each case is the high order bit of the byte, indicating
2031 that an additional byte follows.
2032
2033
2034 The encoding for signed, two\textquoteright s complement LEB128 
2035 (\addtoindex{SLEB128}) \addtoindexx{LEB128!signed, encoding as}
2036 numbers is similar, except that the criterion for discarding
2037 high order bytes is not whether they are zero, but whether
2038 they consist entirely of sign extension bits. Consider the
2039 32\dash bit integer -2. The three high level bytes of the number
2040 are sign extension, thus LEB128 would represent it as a single
2041 byte containing the low order 7 bits, with the high order
2042 bit cleared to indicate the end of the byte stream. Note
2043 that there is nothing within the LEB128 representation that
2044 indicates whether an encoded number is signed or unsigned. The
2045 decoder must know what type of number to expect. 
2046 Table \refersec{tab:examplesofunsignedleb128encodings}
2047 gives some examples of unsigned LEB128\addtoindexx{LEB128!unsigned}
2048 numbers and Table \refersec{tab:examplesofsignedleb128encodings}
2049 gives some examples of signed LEB128\addtoindexx{LEB128!signed} 
2050 numbers.
2051
2052 \textit{Appendix \refersec{app:variablelengthdataencodingdecodinginformative} 
2053 \addtoindexx{LEB128!examples}
2054 gives algorithms for encoding and decoding these forms.}
2055
2056 \needlines{8}
2057 \begin{centering}
2058 \setlength{\extrarowheight}{0.1cm}
2059 \begin{longtable}{c|c|c}
2060   \caption{Examples of unsigned LEB128 encodings}
2061   \label{tab:examplesofunsignedleb128encodings} 
2062   \addtoindexx{LEB128 encoding!examples}\addtoindexx{LEB128!unsigned} \\
2063   \hline \bfseries Number&\bfseries First byte &\bfseries Second byte \\ \hline
2064 \endfirsthead
2065   \bfseries Number&\bfseries First Byte &\bfseries Second byte\\ \hline
2066 \endhead
2067   \hline \emph{Continued on next page}
2068 \endfoot
2069   \hline
2070 \endlastfoot
2071 2&2& --- \\
2072 127&127& ---\\
2073 128& 0 + 0x80 & 1 \\
2074 129& 1 + 0x80 & 1 \\
2075 %130& 2 + 0x80 & 1 \\
2076 12857& 57 + 0x80 & 100 \\
2077 \end{longtable}
2078 \end{centering}
2079
2080
2081
2082 \begin{centering}
2083 \setlength{\extrarowheight}{0.1cm}
2084 \begin{longtable}{c|c|c}
2085   \caption{Examples of signed LEB128 encodings} 
2086   \label{tab:examplesofsignedleb128encodings} 
2087   \addtoindexx{LEB128!signed} \\
2088   \hline \bfseries Number&\bfseries First byte &\bfseries Second byte \\ \hline
2089 \endfirsthead
2090   \bfseries Number&\bfseries First Byte &\bfseries Second byte\\ \hline
2091 \endhead
2092   \hline \emph{Continued on next page}
2093 \endfoot
2094   \hline
2095 \endlastfoot
2096 2&2& --- \\
2097 -2&0x7e& ---\\
2098 127& 127 + 0x80 & 0 \\
2099 -127& 1 + 0x80 & 0x7f \\
2100 128& 0 + 0x80 & 1 \\
2101 -128& 0 + 0x80 & 0x7f \\
2102 129& 1 + 0x80 & 1 \\
2103 -129& 0x7f + 0x80 & 0x7e \\
2104
2105 \end{longtable}
2106 \end{centering}
2107
2108
2109
2110 \section{DWARF Expressions and Location Descriptions}
2111 \label{datarep:dwarfexpressionsandlocationdescriptions}
2112 \subsection{DWARF Expressions}
2113 \label{datarep:dwarfexpressions}
2114
2115
2116 \addtoindexx{DWARF expression!operator encoding}
2117 DWARF expression is stored in a \nolink{block} of contiguous
2118 bytes. The bytes form a sequence of operations. Each operation
2119 is a 1\dash byte code that identifies that operation, followed by
2120 zero or more bytes of additional data. The encodings for the
2121 operations are described in 
2122 Table \refersec{tab:dwarfoperationencodings}. 
2123
2124 \begin{centering}
2125 \setlength{\extrarowheight}{0.1cm}
2126 \begin{longtable}{l|c|c|l}
2127   \caption{DWARF operation encodings} \label{tab:dwarfoperationencodings} \\
2128   \hline & &\bfseries No. of  &\\ 
2129   \bfseries Operation&\bfseries Code &\bfseries Operands &\bfseries Notes\\ \hline
2130 \endfirsthead
2131    & &\bfseries No. of &\\ 
2132   \bfseries Operation&\bfseries Code &\bfseries  Operands &\bfseries Notes\\ \hline
2133 \endhead
2134   \hline \emph{Continued on next page}
2135 \endfoot
2136   \hline \ddag\ \textit{New in DWARF Version 5}
2137 \endlastfoot
2138
2139 \DWOPaddr&0x03&1 & constant address  \\ 
2140 & & &(size is target specific) \\
2141
2142 \DWOPderef&0x06&0 & \\
2143
2144 \DWOPconstoneu&0x08&1&1\dash byte constant  \\
2145 \DWOPconstones&0x09&1&1\dash byte constant   \\
2146 \DWOPconsttwou&0x0a&1&2\dash byte constant   \\
2147 \DWOPconsttwos&0x0b&1&2\dash byte constant   \\
2148 \DWOPconstfouru&0x0c&1&4\dash byte constant    \\
2149 \DWOPconstfours&0x0d&1&4\dash byte constant   \\
2150 \DWOPconsteightu&0x0e&1&8\dash byte constant   \\
2151 \DWOPconsteights&0x0f&1&8\dash byte constant   \\
2152 \DWOPconstu&0x10&1&ULEB128 constant   \\
2153 \DWOPconsts&0x11&1&SLEB128 constant   \\
2154 \DWOPdup&0x12&0 &   \\
2155 \DWOPdrop&0x13&0  &   \\
2156 \DWOPover&0x14&0 &   \\
2157 \DWOPpick&0x15&1&1\dash byte stack index   \\
2158 \DWOPswap&0x16&0 &   \\
2159 \DWOProt&0x17&0 &   \\
2160 \DWOPxderef&0x18&0 &   \\
2161 \DWOPabs&0x19&0 &   \\
2162 \DWOPand&0x1a&0 &   \\
2163 \DWOPdiv&0x1b&0 &   \\
2164 \DWOPminus&0x1c&0 & \\
2165 \DWOPmod&0x1d&0 & \\
2166 \DWOPmul&0x1e&0 & \\
2167 \DWOPneg&0x1f&0 & \\
2168 \DWOPnot&0x20&0 & \\
2169 \DWOPor&0x21&0 & \\
2170 \DWOPplus&0x22&0 & \\
2171 \DWOPplusuconst&0x23&1&ULEB128 addend \\
2172 \DWOPshl&0x24&0 & \\
2173 \DWOPshr&0x25&0 & \\
2174 \DWOPshra&0x26&0 & \\
2175 \DWOPxor&0x27&0 & \\
2176
2177 \DWOPbra&0x28&1 & signed 2\dash byte constant \\
2178 \DWOPeq&0x29&0 & \\
2179 \DWOPge&0x2a&0 & \\
2180 \DWOPgt&0x2b&0 & \\
2181 \DWOPle&0x2c&0 & \\
2182 \DWOPlt&0x2d&0  & \\
2183 \DWOPne&0x2e&0 & \\
2184 \DWOPskip&0x2f&1&signed 2\dash byte constant \\ \hline
2185
2186 \DWOPlitzero & 0x30 & 0 & \\
2187 \DWOPlitone  & 0x31 & 0& literals 0 .. 31 = \\
2188 \ldots & & &\hspace{0.3cm}(\DWOPlitzero{} + literal) \\
2189 \DWOPlitthirtyone & 0x4f & 0 & \\ \hline
2190
2191 \DWOPregzero & 0x50 & 0 & \\*
2192 \DWOPregone  & 0x51 & 0&reg 0 .. 31 = \\*
2193 \ldots & & &\hspace{0.3cm}(\DWOPregzero{} + regnum) \\*
2194 \DWOPregthirtyone & 0x6f & 0 & \\ \hline
2195
2196 \DWOPbregzero & 0x70 &1 & SLEB128 offset \\*
2197 \DWOPbregone  & 0x71 & 1 &base register 0 .. 31 = \\*
2198 ... & &              &\hspace{0.3cm}(\DWOPbregzero{} + regnum) \\*
2199 \DWOPbregthirtyone & 0x8f & 1 & \\ \hline
2200
2201 \DWOPregx{} & 0x90 &1&ULEB128 register \\
2202 \DWOPfbreg{} & 0x91&1&SLEB128 offset \\
2203 \DWOPbregx{} & 0x92&2 &ULEB128 register, \\*
2204                   & & &SLEB128 offset \\
2205 \DWOPpiece{} & 0x93 &1& ULEB128 size of piece \\
2206 \DWOPderefsize{} & 0x94 &1& 1-byte size of data retrieved \\
2207 \DWOPxderefsize{} & 0x95&1&1-byte size of data retrieved \\
2208 \DWOPnop{} & 0x96 &0& \\
2209
2210 \DWOPpushobjectaddress&0x97&0 &  \\
2211 \DWOPcalltwo&0x98&1& 2\dash byte offset of DIE \\
2212 \DWOPcallfour&0x99&1& 4\dash byte offset of DIE \\
2213 \DWOPcallref&0x9a&1& 4\dash\  or 8\dash byte offset of DIE \\
2214 \DWOPformtlsaddress&0x9b &0& \\
2215 \DWOPcallframecfa{} &0x9c &0& \\
2216 \DWOPbitpiece&0x9d &2&ULEB128 size, \\*
2217                    &&&ULEB128 offset\\
2218 \DWOPimplicitvalue{} &0x9e &2&ULEB128 size, \\*
2219                    &&&\nolink{block} of that size\\
2220 \DWOPstackvalue{} &0x9f &0& \\
2221 \DWOPimplicitpointer{}~\ddag &0xa0& 2 &4- or 8-byte offset of DIE, \\*
2222                               &&&SLEB128 constant offset \\
2223 \DWOPaddrx~\ddag&0xa1&1&ULEB128 indirect address \\
2224 \DWOPconstx~\ddag&0xa2&1&ULEB128 indirect constant   \\
2225 \DWOPentryvalue~\ddag&0xa3&2&ULEB128 size, \\*
2226                    &&&\nolink{block} of that size\\
2227 \DWOPconsttype~\ddag    & 0xa4 & 3 & ULEB128 type entry offset,\\*
2228                                & & & 1-byte size, \\*
2229                                & & & constant value \\
2230 \DWOPregvaltype~\ddag   & 0xa5 & 2 & ULEB128 register number, \\*
2231                                  &&& ULEB128 constant offset \\
2232 \DWOPdereftype~\ddag    & 0xa6 & 2 & 1-byte size, \\*
2233                                  &&& ULEB128 type entry offset \\
2234 \DWOPxdereftype~\ddag   & 0xa7 & 2 & 1-byte size, \\*
2235                                  &&& ULEB128 type entry offset \\
2236 \DWOPconvert~\ddag      & 0xa8 & 1 & ULEB128 type entry offset \\
2237 \DWOPreinterpret~\ddag  & 0xa9 & 1 & ULEB128 type entry offset \\
2238 \DWOPlouser{} &0xe0 && \\
2239 \DWOPhiuser{} &\xff && \\
2240
2241 \end{longtable}
2242 \end{centering}
2243
2244
2245 \subsection{Location Descriptions}
2246 \label{datarep:locationdescriptions}
2247
2248 A location description is used to compute the 
2249 location of a variable or other entity.
2250
2251 \subsection{Location Lists}
2252 \label{datarep:locationlists}
2253
2254 Each entry in a \addtoindex{location list} is either a location list entry,
2255 a base address selection entry, or an 
2256 \addtoindexx{end-of-list entry!in location list}
2257 end-of-list entry.
2258
2259 \needlines{6}
2260 \subsubsection{Location List Entries in Non-Split Objects}
2261 A \addtoindex{location list} entry consists of two address offsets followed
2262 by an unsigned 2\dash byte length, followed by a block of contiguous bytes
2263 that contains a DWARF location description. The length
2264 specifies the number of bytes in that block. The two offsets
2265 are the same size as an address on the target machine.
2266
2267 \needlines{5}
2268 A base address selection entry and an 
2269 \addtoindexx{end-of-list entry!in location list}
2270 end-of-list entry each
2271 consist of two (constant or relocated) address offsets. The two
2272 offsets are the same size as an address on the target machine.
2273
2274 For a \addtoindex{location list} to be specified, the base address of
2275 \addtoindexx{base address selection entry!in location list}
2276 the corresponding compilation unit must be defined 
2277 (see Section \refersec{chap:normalandpartialcompilationunitentries}).
2278
2279 \subsubsection{Location List Entries in Split Objects}
2280 \label{datarep:locationlistentriesinsplitobjects}
2281 An alternate form for location list entries is used in split objects. 
2282 Each entry begins with an unsigned 1-byte code that indicates the kind of entry
2283 that follows. The encodings for these constants are given in
2284 Table \refersec{tab:locationlistentryencodingvalues}.
2285
2286 \begin{centering}
2287 \setlength{\extrarowheight}{0.1cm}
2288 \begin{longtable}{l|c}
2289   \caption{Location list entry encoding values} \label{tab:locationlistentryencodingvalues} \\
2290   \hline \bfseries Location list entry encoding name&\bfseries Value \\ \hline
2291 \endfirsthead
2292   \bfseries Location list entry encoding name&\bfseries Value\\ \hline
2293 \endhead
2294   \hline \emph{Continued on next page}
2295 \endfoot
2296   \hline
2297 \endlastfoot
2298 \DWLLEendoflistentry & 0x0 \\
2299 \DWLLEbaseaddressselectionentry & 0x01 \\
2300 \DWLLEstartendentry & 0x02 \\
2301 \DWLLEstartlengthentry & 0x03 \\
2302 \DWLLEoffsetpairentry & 0x04 \\
2303 \end{longtable}
2304 \end{centering}
2305
2306 \section{Base Type Attribute Encodings}
2307 \label{datarep:basetypeattributeencodings}
2308
2309 The encodings of the 
2310 \hypertarget{chap:DWATencodingencodingofbasetype}{}
2311 constants used in 
2312 \addtoindexx{encoding attribute}
2313 the 
2314 \DWATencoding{}
2315 attribute are given in 
2316 Table \refersec{tab:basetypeencodingvalues}
2317
2318 \begin{centering}
2319 \setlength{\extrarowheight}{0.1cm}
2320 \begin{longtable}{l|c}
2321   \caption{Base type encoding values} \label{tab:basetypeencodingvalues} \\
2322   \hline \bfseries Base type encoding name&\bfseries Value \\ \hline
2323 \endfirsthead
2324   \bfseries Base type encoding name&\bfseries Value\\ \hline
2325 \endhead
2326   \hline \emph{Continued on next page}
2327 \endfoot
2328   \hline
2329   \ddag \ \textit{New in \DWARFVersionV}
2330 \endlastfoot
2331 \DWATEaddress&0x01 \\
2332 \DWATEboolean&0x02 \\
2333 \DWATEcomplexfloat&0x03 \\
2334 \DWATEfloat&0x04 \\
2335 \DWATEsigned&0x05 \\
2336 \DWATEsignedchar&0x06 \\
2337 \DWATEunsigned&0x07 \\
2338 \DWATEunsignedchar&0x08 \\
2339 \DWATEimaginaryfloat&0x09 \\
2340 \DWATEpackeddecimal&0x0a \\
2341 \DWATEnumericstring&0x0b \\
2342 \DWATEedited&0x0c \\
2343 \DWATEsignedfixed&0x0d \\
2344 \DWATEunsignedfixed&0x0e \\
2345 \DWATEdecimalfloat & 0x0f \\
2346 \DWATEUTF{} & 0x10 \\
2347 \DWATEUCS~\ddag   & 0x11 \\
2348 \DWATEASCII~\ddag & 0x12 \\
2349 \DWATElouser{} & 0x80 \\
2350 \DWATEhiuser{} & \xff \\
2351 \end{longtable}
2352 \end{centering}
2353
2354 \needlines{4}
2355 The encodings of the constants used in the 
2356 \DWATdecimalsign{} attribute 
2357 are given in 
2358 Table \refersec{tab:decimalsignencodings}.
2359
2360 \begin{centering}
2361 \setlength{\extrarowheight}{0.1cm}
2362 \begin{longtable}{l|c}
2363   \caption{Decimal sign encodings} \label{tab:decimalsignencodings} \\
2364   \hline \bfseries Decimal sign code name&\bfseries Value \\ \hline
2365 \endfirsthead
2366   \bfseries Decimal sign code name&\bfseries Value\\ \hline
2367 \endhead
2368   \hline \emph{Continued on next page}
2369 \endfoot
2370   \hline
2371 \endlastfoot
2372
2373 \DWDSunsigned{} & 0x01  \\
2374 \DWDSleadingoverpunch{} & 0x02  \\
2375 \DWDStrailingoverpunch{} & 0x03  \\
2376 \DWDSleadingseparate{} & 0x04  \\
2377 \DWDStrailingseparate{} & 0x05  \\
2378
2379 \end{longtable}
2380 \end{centering}
2381
2382 \needlines{9}
2383 The encodings of the constants used in the 
2384 \DWATendianity{} attribute are given in 
2385 Table \refersec{tab:endianityencodings}.
2386
2387 \begin{centering}
2388 \setlength{\extrarowheight}{0.1cm}
2389 \begin{longtable}{l|c}
2390   \caption{Endianity encodings} \label{tab:endianityencodings}\\
2391   \hline \bfseries Endian code name&\bfseries Value \\ \hline
2392 \endfirsthead
2393   \bfseries Endian code name&\bfseries Value\\ \hline
2394 \endhead
2395   \hline \emph{Continued on next page}
2396 \endfoot
2397   \hline
2398 \endlastfoot
2399
2400 \DWENDdefault{}  & 0x00 \\
2401 \DWENDbig{} & 0x01 \\
2402 \DWENDlittle{} & 0x02 \\
2403 \DWENDlouser{} & 0x40 \\
2404 \DWENDhiuser{} & \xff \\
2405
2406 \end{longtable}
2407 \end{centering}
2408
2409 \section{Accessibility Codes}
2410 \label{datarep:accessibilitycodes}
2411 The encodings of the constants used in the 
2412 \DWATaccessibility{}
2413 attribute 
2414 \addtoindexx{accessibility attribute}
2415 are given in 
2416 Table \refersec{tab:accessibilityencodings}.
2417
2418 \begin{centering}
2419 \setlength{\extrarowheight}{0.1cm}
2420 \begin{longtable}{l|c}
2421   \caption{Accessibility encodings} \label{tab:accessibilityencodings}\\
2422   \hline \bfseries Accessibility code name&\bfseries Value \\ \hline
2423 \endfirsthead
2424   \bfseries Accessibility code name&\bfseries Value\\ \hline
2425 \endhead
2426   \hline \emph{Continued on next page}
2427 \endfoot
2428   \hline
2429 \endlastfoot
2430
2431 \DWACCESSpublic&0x01  \\
2432 \DWACCESSprotected&0x02 \\
2433 \DWACCESSprivate&0x03 \\
2434
2435 \end{longtable}
2436 \end{centering}
2437
2438
2439 \section{Visibility Codes}
2440 \label{datarep:visibilitycodes}
2441 The encodings of the constants used in the 
2442 \DWATvisibility{} attribute are given in 
2443 Table \refersec{tab:visibilityencodings}. 
2444
2445 \begin{centering}
2446 \setlength{\extrarowheight}{0.1cm}
2447 \begin{longtable}{l|c}
2448   \caption{Visibility encodings} \label{tab:visibilityencodings}\\
2449   \hline \bfseries Visibility code name&\bfseries Value \\ \hline
2450 \endfirsthead
2451   \bfseries Visibility code name&\bfseries Value\\ \hline
2452 \endhead
2453   \hline \emph{Continued on next page}
2454 \endfoot
2455   \hline
2456 \endlastfoot
2457
2458 \DWVISlocal&0x01 \\
2459 \DWVISexported&0x02 \\
2460 \DWVISqualified&0x03 \\
2461
2462 \end{longtable}
2463 \end{centering}
2464
2465 \section{Virtuality Codes}
2466 \label{datarep:vitualitycodes}
2467
2468 The encodings of the constants used in the 
2469 \DWATvirtuality{} attribute are given in 
2470 Table \refersec{tab:virtualityencodings}.
2471
2472 \begin{centering}
2473 \setlength{\extrarowheight}{0.1cm}
2474 \begin{longtable}{l|c}
2475   \caption{Virtuality encodings} \label{tab:virtualityencodings}\\
2476   \hline \bfseries Virtuality code name&\bfseries Value \\ \hline
2477 \endfirsthead
2478   \bfseries Virtuality code name&\bfseries Value\\ \hline
2479 \endhead
2480   \hline \emph{Continued on next page}
2481 \endfoot
2482   \hline
2483 \endlastfoot
2484
2485 \DWVIRTUALITYnone&0x00 \\
2486 \DWVIRTUALITYvirtual&0x01 \\
2487 \DWVIRTUALITYpurevirtual&0x02 \\
2488
2489
2490
2491 \end{longtable}
2492 \end{centering}
2493
2494 The value 
2495 \DWVIRTUALITYnone{} is equivalent to the absence of the 
2496 \DWATvirtuality{}
2497 attribute.
2498
2499 \section{Source Languages}
2500 \label{datarep:sourcelanguages}
2501
2502 The encodings of the constants used 
2503 \addtoindexx{language attribute, encoding}
2504 in 
2505 \addtoindexx{language name encoding}
2506 the 
2507 \DWATlanguage{}
2508 attribute are given in 
2509 Table \refersec{tab:languageencodings}.
2510 Names marked with
2511 % If we don't force a following space it looks odd
2512 \dag \  
2513 and their associated values are reserved, but the
2514 languages they represent are not well supported. 
2515 Table \refersec{tab:languageencodings}
2516 also shows the 
2517 \addtoindexx{lower bound attribute!default}
2518 default lower bound, if any, assumed for
2519 an omitted \DWATlowerbound{} attribute in the context of a
2520 \DWTAGsubrangetype{} debugging information entry for each
2521 defined language.
2522
2523 \begin{centering}
2524 \setlength{\extrarowheight}{0.1cm}
2525 \begin{longtable}{l|c|c}
2526   \caption{Language encodings} \label{tab:languageencodings}\\
2527   \hline \bfseries Language name&\bfseries Value &\bfseries Default Lower Bound \\ \hline
2528 \endfirsthead
2529   \bfseries Language name&\bfseries Value &\bfseries Default Lower Bound\\ \hline
2530 \endhead
2531   \hline \emph{Continued on next page}
2532 \endfoot
2533   \hline
2534   \dag \ \textit{See text} \\ \ddag \ \textit{New in \DWARFVersionV}
2535 \endlastfoot
2536 \addtoindexx{ISO-defined language names}
2537
2538 \DWLANGCeightynine &0x0001 &0 \addtoindexx{C:1989 (ISO)}      \\
2539 \DWLANGC{} &0x0002 &0  \addtoindexx{C!non-standard} \\
2540 \DWLANGAdaeightythree{} \dag &0x0003 &1  \addtoindexx{Ada:1983 (ISO)}     \\
2541 \DWLANGCplusplus{} &0x0004 &0 \addtoindexx{C++:1998 (ISO)}      \\
2542 \DWLANGCobolseventyfour{} \dag &0x0005 &1 \addtoindexx{COBOL:1974 (ISO)}      \\
2543 \DWLANGCoboleightyfive{} \dag &0x0006 &1 \addtoindexx{COBOL:1985 (ISO)}      \\
2544 \DWLANGFortranseventyseven &0x0007 &1 \addtoindexx{FORTRAN:1977 (ISO)}      \\
2545 \DWLANGFortranninety &0x0008 &1 \addtoindexx{Fortran:1990 (ISO)}      \\
2546 \DWLANGPascaleightythree &0x0009 &1 \addtoindexx{Pascal:1983 (ISO)}      \\
2547 \DWLANGModulatwo &0x000a &1 \addtoindexx{Modula-2:1996 (ISO)}      \\
2548 \DWLANGJava &0x000b &0 \addtoindexx{Java}      \\
2549 \DWLANGCninetynine &0x000c &0 \addtoindexx{C:1999 (ISO)}      \\
2550 \DWLANGAdaninetyfive{} \dag &0x000d &1 \addtoindexx{Ada:1995 (ISO)}      \\
2551 \DWLANGFortranninetyfive &0x000e &1 \addtoindexx{Fortran:1995 (ISO)}      \\
2552 \DWLANGPLI{} \dag &0x000f &1 \addtoindexx{PL/I:1976 (ANSI)}\\
2553 \DWLANGObjC{} &0x0010 &0 \addtoindexx{Objective C}\\
2554 \DWLANGObjCplusplus{} &0x0011 &0 \addtoindexx{Objective C++}\\
2555 \DWLANGUPC{} &0x0012 &0 \addtoindexx{UPC}\\
2556 \DWLANGD{} &0x0013 &0 \addtoindexx{D language}\\
2557 \DWLANGPython{} \dag &0x0014 &0 \addtoindexx{Python}\\
2558 \DWLANGOpenCL{} \dag \ddag &0x0015 &0 \addtoindexx{OpenCL}\\
2559 \DWLANGGo{} \dag \ddag &0x0016 &0 \addtoindexx{Go}\\
2560 \DWLANGModulathree{} \dag \ddag &0x0017 &1 \addtoindexx{Modula-3}\\
2561 \DWLANGHaskell{} \dag \ddag &0x0018 &0 \addtoindexx{Haskell}\\
2562 \DWLANGCpluspluszerothree{} \ddag &0x0019 &0 \addtoindexx{C++:2003 (ISO)}\\
2563 \DWLANGCpluspluseleven{} \ddag &0x001a &0 \addtoindexx{C++:2011 (ISO)}\\
2564 \DWLANGOCaml{} \ddag &0x001b &0 \addtoindexx{OCaml}\\
2565 \DWLANGRust{} \ddag &0x001c &0 \addtoindexx{Rust}\\
2566 \DWLANGCeleven{} \ddag &0x001d &0 \addtoindexx{C:2011 (ISO)}\\
2567 \DWLANGSwift{} \ddag &0x001e &0 \addtoindexx{Swift} \\
2568 \DWLANGJulia{} \ddag &0x001f &1 \addtoindexx{Julia} \\
2569 \DWLANGDylan{} \ddag &0x0020 &0 \addtoindexx{Dylan} \\
2570 \DWLANGCplusplusfourteen{}~\ddag &0x0021 &0 \addtoindexx{C++:2014 (ISO)}     \\
2571 \DWLANGFortranzerothree{}~\ddag  &0x0022 &1 \addtoindexx{Fortran:2004 (ISO)} \\
2572 \DWLANGFortranzeroeight{}~\ddag  &0x0023 &1 \addtoindexx{Fortran:2010 (ISO)} \\
2573 \DWLANGlouser{} &0x8000 & \\
2574 \DWLANGhiuser{} &\xffff & \\
2575
2576 \end{longtable}
2577 \end{centering}
2578
2579 \section{Address Class Encodings}
2580 \label{datarep:addressclassencodings}
2581
2582 The value of the common 
2583 \addtoindex{address class} encoding 
2584 \DWADDRnone{} is 0.
2585
2586 \needlines{7}
2587 \section{Identifier Case}
2588 \label{datarep:identifiercase}
2589
2590 The encodings of the constants used in the 
2591 \DWATidentifiercase{} attribute are given in 
2592 Table \refersec{tab:identifiercaseencodings}.
2593
2594 \begin{centering}
2595 \setlength{\extrarowheight}{0.1cm}
2596 \begin{longtable}{l|c}
2597   \caption{Identifier case encodings} \label{tab:identifiercaseencodings}\\
2598   \hline \bfseries Identifier case name&\bfseries Value \\ \hline
2599 \endfirsthead
2600   \bfseries Identifier case name&\bfseries Value\\ \hline
2601 \endhead
2602   \hline \emph{Continued on next page}
2603 \endfoot
2604   \hline
2605 \endlastfoot
2606 \DWIDcasesensitive&0x00     \\
2607 \DWIDupcase&0x01     \\
2608 \DWIDdowncase&0x02     \\
2609 \DWIDcaseinsensitive&0x03     \\
2610 \end{longtable}
2611 \end{centering}
2612
2613 \section{Calling Convention Encodings}
2614 \label{datarep:callingconventionencodings}
2615 The encodings of the constants used in the 
2616 \DWATcallingconvention{} attribute are given in
2617 Table \refersec{tab:callingconventionencodings}.
2618
2619 \begin{centering}
2620 \setlength{\extrarowheight}{0.1cm}
2621 \begin{longtable}{l|c}
2622   \caption{Calling convention encodings} \label{tab:callingconventionencodings}\\
2623   \hline \bfseries Calling convention name&\bfseries Value \\ \hline
2624 \endfirsthead
2625   \bfseries Calling convention name&\bfseries Value\\ \hline
2626 \endhead
2627   \hline \emph{Continued on next page}
2628 \endfoot
2629   \hline \ddag\ \textit{New in DWARF Version 5}
2630 \endlastfoot
2631
2632 \DWCCnormal &0x01     \\
2633 \DWCCprogram&0x02     \\
2634 \DWCCnocall &0x03     \\
2635 \DWCCpassbyreference~\ddag &0x04 \\
2636 \DWCCpassbyvalue~\ddag     &0x05 \\
2637 \DWCClouser &0x40     \\
2638 \DWCChiuser&\xff     \\
2639
2640 \end{longtable}
2641 \end{centering}
2642
2643 \needlines{12}
2644 \section{Inline Codes}
2645 \label{datarep:inlinecodes}
2646
2647 The encodings of the constants used in 
2648 \addtoindexx{inline attribute}
2649 the 
2650 \DWATinline{} attribute are given in 
2651 Table \refersec{tab:inlineencodings}.
2652
2653 \needlines{8}
2654 \begin{centering}
2655 \setlength{\extrarowheight}{0.1cm}
2656 \begin{longtable}{l|c}
2657   \caption{Inline encodings} \label{tab:inlineencodings}\\
2658   \hline \bfseries Inline code name&\bfseries Value \\ \hline
2659 \endfirsthead
2660   \bfseries Inline Code name&\bfseries Value\\ \hline
2661 \endhead
2662   \hline \emph{Continued on next page}
2663 \endfoot
2664   \hline
2665 \endlastfoot
2666
2667 \DWINLnotinlined&0x00      \\
2668 \DWINLinlined&0x01      \\
2669 \DWINLdeclarednotinlined&0x02      \\
2670 \DWINLdeclaredinlined&0x03      \\
2671
2672 \end{longtable}
2673 \end{centering}
2674
2675 % this clearpage is ugly, but the following table came
2676 % out oddly without it.
2677
2678 \section{Array Ordering}
2679 \label{datarep:arrayordering}
2680
2681 The encodings of the constants used in the 
2682 \DWATordering{} attribute are given in 
2683 Table \refersec{tab:orderingencodings}.
2684
2685 \needlines{8}
2686 \begin{centering}
2687 \setlength{\extrarowheight}{0.1cm}
2688 \begin{longtable}{l|c}
2689   \caption{Ordering encodings} \label{tab:orderingencodings}\\
2690   \hline \bfseries Ordering name&\bfseries Value \\ \hline
2691 \endfirsthead
2692   \bfseries Ordering name&\bfseries Value\\ \hline
2693 \endhead
2694   \hline \emph{Continued on next page}
2695 \endfoot
2696   \hline
2697 \endlastfoot
2698
2699 \DWORDrowmajor&0x00  \\
2700 \DWORDcolmajor&0x01  \\
2701
2702 \end{longtable}
2703 \end{centering}
2704
2705
2706 \section{Discriminant Lists}
2707 \label{datarep:discriminantlists}
2708
2709 The descriptors used in 
2710 \addtoindexx{discriminant list attribute}
2711 the 
2712 \DWATdiscrlist{} attribute are 
2713 encoded as 1\dash byte constants. The
2714 defined values are given in 
2715 Table \refersec{tab:discriminantdescriptorencodings}.
2716
2717 % Odd that the 'Name' field capitalized here, it is not caps elsewhere.
2718 \begin{centering}
2719 \setlength{\extrarowheight}{0.1cm}
2720 \begin{longtable}{l|c}
2721   \caption{Discriminant descriptor encodings} \label{tab:discriminantdescriptorencodings}\\
2722   \hline \bfseries Descriptor name&\bfseries Value \\ \hline
2723 \endfirsthead
2724   \bfseries Descriptor name&\bfseries Value\\ \hline
2725 \endhead
2726   \hline \emph{Continued on next page}
2727 \endfoot
2728   \hline
2729 \endlastfoot
2730
2731 \DWDSClabel&0x00 \\
2732 \DWDSCrange&0x01 \\
2733
2734 \end{longtable}
2735 \end{centering}
2736
2737 \needlines{6}
2738 \section{Name Index Table}
2739 \label{datarep:nameindextable}
2740 Each name index table in the \dotdebugnames{} section 
2741 begins with a header consisting of:
2742 \begin{enumerate}[1. ]
2743 \item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
2744 \addttindexx{unit\_length}
2745 A 4-byte or 12-byte initial length field that 
2746 contains the size in bytes of this contribution to the \dotdebugnames{} 
2747 section, not including the length field itself
2748 (see Section \refersec{datarep:initiallengthvalues}).
2749
2750 \item \texttt{version} (\addtoindex{uhalf}) \\
2751 A 2-byte version number\addtoindexx{version number!name index table} 
2752 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}). 
2753 This number is specific to the name index table and is
2754 independent of the DWARF version number.
2755
2756 The value in this field is \versiondotdebugnames.
2757
2758 \item padding (\addtoindex{uhalf}) \\
2759
2760 \item \texttt{comp\_unit\_count} (4-byte unsigned integer) \\
2761 The number of CUs in the CU list.
2762
2763 \item \texttt{local\_type\_unit\_count} (4-byte unsigned integer) \\
2764 The number of TUs in the first TU list.
2765
2766 \item \texttt{foreign\_type\_unit\_count} (4-byte unsigned integer) \\
2767 The number of TUs in the second TU list.
2768
2769 \item \texttt{bucket\_count} (4-byte unsigned integer) \\
2770 The number of hash buckets in the hash lookup table. 
2771 If there is no hash lookup table, this field contains 0.
2772
2773 \item \texttt{name\_count} (4-byte unsigned integer) \\
2774 The number of unique names in the index.
2775
2776 \item \texttt{abbrev\_table\_size} (4-byte unsigned integer) \\
2777 The size in bytes of the abbreviations table.
2778
2779 \item \texttt{augmentation\_string\_size} (4-byte unsigned integer) \\
2780 The size in bytes of the augmentation string. This value should be
2781 rounded up to a multiple of 4.
2782
2783 \item \texttt{augmentation\_string} (sequence of characters) \\
2784 A vendor-specific augmentation string, which provides additional 
2785 information about the contents of this index. If provided, the string
2786 should begin with a 4-character vendor ID. The remainder of the
2787 string is meant to be read by a cooperating consumer, and its
2788 contents and interpretation are not specified here. The
2789 string should be padded with null characters to a multiple of
2790 four bytes in length.
2791
2792 \end{enumerate}
2793
2794 The name index attributes and their encodings are listed in Table \referfol{datarep:indexattributeencodings}.
2795
2796 \begin{centering}
2797 \setlength{\extrarowheight}{0.1cm}
2798 \begin{longtable}{l|c|l}
2799   \caption{Name index attribute encodings} \label{datarep:indexattributeencodings}\\
2800   \hline \bfseries Attribute name&\bfseries Value &\bfseries Form/Class \\ \hline
2801 \endfirsthead
2802   \bfseries Attribute name&\bfseries Value &\bfseries Form/Class \\ \hline
2803 \endhead
2804   \hline \emph{Continued on next page}
2805 \endfoot
2806   \hline
2807   \ddag \ \textit{New in \DWARFVersionV}
2808 \endlastfoot
2809 \DWIDXcompileunit~\ddag & 1        & \CLASSconstant \\
2810 \DWIDXtypeunit~\ddag    & 2        & \CLASSconstant \\
2811 \DWIDXdieoffset~\ddag   & 3        & \CLASSreference \\
2812 \DWIDXparent~\ddag      & 4        & \CLASSconstant \\
2813 \DWIDXtypehash~\ddag    & 5        & \DWFORMdataeight \\
2814 \DWIDXlouser~\ddag      & 0x2000   & \\
2815 \DWIDXhiuser~\ddag      & \xiiifff & \\
2816 \end{longtable}
2817 \end{centering}
2818
2819 The abbreviations table ends with an entry consisting of a single 0
2820 byte for the abbreviation code. The size of the table given by
2821 \texttt{abbrev\_table\_size} may include optional padding following the
2822 terminating 0 byte.
2823
2824 \section{Defaulted Member Encodings}
2825 \hypertarget{datarep:defaultedmemberencodings}{}
2826
2827 The encodings of the constants used in the \DWATdefaulted{} attribute
2828 are given in Table \referfol{datarep:defaultedattributeencodings}.
2829
2830 \begin{centering}
2831 \setlength{\extrarowheight}{0.1cm}
2832 \begin{longtable}{l|c}
2833   \caption{Defaulted attribute encodings} \label{datarep:defaultedattributeencodings}\\
2834   \hline \bfseries Defaulted name&\bfseries Value \\ \hline
2835 \endfirsthead
2836   \bfseries Defaulted name&\bfseries Value \\ \hline
2837 \endhead
2838   \hline \emph{Continued on next page}
2839 \endfoot
2840   \hline
2841   \ddag \ \textit{New in \DWARFVersionV}
2842 \endlastfoot
2843 \DWDEFAULTEDno~\ddag   & 0x00 \\
2844 \DWDEFAULTEDinclass~\ddag       & 0x01 \\
2845 \DWDEFAULTEDoutofclass~\ddag    & 0x02 \\
2846 \end{longtable}
2847 \end{centering}
2848
2849 \needlines{10}
2850 \section{Address Range Table}
2851 \label{datarep:addrssrangetable}
2852
2853 Each set of entries in the table of address ranges contained
2854 in the \dotdebugaranges{}
2855 section begins with a header containing:
2856 \begin{enumerate}[1. ]
2857 % FIXME The unit length text is not fully consistent across
2858 % these tables.
2859
2860 \item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
2861 \addttindexx{unit\_length}
2862 A 4-byte or 12-byte length containing the length of the
2863 \addtoindexx{initial length}
2864 set of entries for this compilation unit, not including the
2865 length field itself. In the \thirtytwobitdwarfformat, this is a
2866 4-byte unsigned integer (which must be less than \xfffffffzero);
2867 in the \sixtyfourbitdwarfformat, this consists of the 4-byte value
2868 \wffffffff followed by an 8-byte unsigned integer that gives
2869 the actual length 
2870 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
2871
2872 \item version (\addtoindex{uhalf}) \\
2873 A 2\dash byte version identifier representing the version of the
2874 DWARF information for the address range table
2875 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
2876
2877 This value in this field \addtoindexx{version number!address range table} is 2. 
2878  
2879 \item debug\_info\_offset (\livelink{datarep:sectionoffsetlength}{section offset}) \\
2880
2881 \addtoindexx{section offset!in .debug\_aranges header}
2882 4\dash byte or 8\dash byte offset into the 
2883 \dotdebuginfo{} section of
2884 the compilation unit header. In the \thirtytwobitdwarfformat,
2885 this is a 4\dash byte unsigned offset; in the \sixtyfourbitdwarfformat,
2886 this is an 8\dash byte unsigned offset 
2887 (see Section \refersec{datarep:32bitand64bitdwarfformats}).
2888
2889 \item \texttt{address\_size} (\addtoindex{ubyte}) \\
2890 A 1\dash byte unsigned integer containing the size in bytes of an
2891 \addttindexx{address\_size}
2892 address 
2893 \addtoindexx{size of an address}
2894 (or the offset portion of an address for segmented
2895 \addtoindexx{address space!segmented}
2896 addressing) on the target system.
2897
2898 \item \texttt{segment\_size} (\addtoindex{ubyte}) \\
2899
2900 \addttindexx{segment\_size}
2901 1\dash byte unsigned integer containing the size in bytes of a
2902 segment selector on the target system.
2903
2904 \end{enumerate}
2905
2906 This header is followed by a series of tuples. Each tuple
2907 consists of a segment, an address and a length. 
2908 The segment
2909 size is given by the \addttindex{segment\_size} field of the header; the
2910 address and length size are each given by the \addttindex{address\_size}
2911 field of the header. 
2912 The first tuple following the header in
2913 each set begins at an offset that is a multiple of the size
2914 of a single tuple (that is, the size of a segment selector
2915 plus twice the \addtoindex{size of an address}). 
2916 The header is padded, if
2917 necessary, to that boundary. Each set of tuples is terminated
2918 by a 0 for the segment, a 0 for the address and 0 for the
2919 length. If the \addttindex{segment\_size} field in the header is zero,
2920 the segment selectors are omitted from all tuples, including
2921 the terminating tuple.
2922
2923
2924 \section{Line Number Information}
2925 \label{datarep:linenumberinformation}
2926
2927 The \addtoindexi{version number}{version number!line number information}
2928 in the line number program header is \versiondotdebugline{}
2929 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}). 
2930
2931 The boolean values \doublequote{true} and \doublequote{false} 
2932 used by the line number information program are encoded
2933 as a single byte containing the value 0 
2934 for \doublequote{false,} and a non-zero value for \doublequote{true.}
2935
2936 \clearpage
2937 \needlines{10}
2938 The encodings for the standard opcodes are given in 
2939 \addtoindexx{line number opcodes!standard opcode encoding}
2940 Table \refersec{tab:linenumberstandardopcodeencodings}.
2941
2942 % Odd that the 'Name' field capitalized here, it is not caps elsewhere.
2943 \begin{centering}
2944 \setlength{\extrarowheight}{0.1cm}
2945 \begin{longtable}{l|c}
2946   \caption{Line number standard opcode encodings} \label{tab:linenumberstandardopcodeencodings}\\
2947   \hline \bfseries Opcode name&\bfseries Value \\ \hline
2948 \endfirsthead
2949   \bfseries Opcode name&\bfseries Value\\ \hline
2950 \endhead
2951   \hline \emph{Continued on next page}
2952 \endfoot
2953   \hline
2954 \endlastfoot
2955
2956 \DWLNScopy&0x01 \\
2957 \DWLNSadvancepc&0x02 \\
2958 \DWLNSadvanceline&0x03 \\
2959 \DWLNSsetfile&0x04 \\
2960 \DWLNSsetcolumn&0x05 \\
2961 \DWLNSnegatestmt&0x06 \\
2962 \DWLNSsetbasicblock&0x07 \\
2963 \DWLNSconstaddpc&0x08 \\
2964 \DWLNSfixedadvancepc&0x09 \\
2965 \DWLNSsetprologueend&0x0a \\*
2966 \DWLNSsetepiloguebegin&0x0b \\*
2967 \DWLNSsetisa&0x0c \\*
2968
2969 \end{longtable}
2970 \end{centering}
2971
2972 \needspace{6cm}
2973 The encodings for the extended opcodes are given in 
2974 \addtoindexx{line number opcodes!extended opcode encoding}
2975 Table \refersec{tab:linenumberextendedopcodeencodings}.
2976
2977 \begin{centering}
2978 \setlength{\extrarowheight}{0.1cm}
2979 \begin{longtable}{l|c}
2980   \caption{Line number extended opcode encodings} \label{tab:linenumberextendedopcodeencodings}\\
2981   \hline \bfseries Opcode name&\bfseries Value \\ \hline
2982 \endfirsthead
2983   \bfseries Opcode name&\bfseries Value\\ \hline
2984 \endhead
2985   \hline \emph{Continued on next page}
2986 \endfoot
2987   \hline %\ddag~\textit{New in DWARF Version 5}
2988 \endlastfoot
2989
2990 \DWLNEendsequence       &0x01 \\
2991 \DWLNEsetaddress        &0x02 \\
2992 \textit{Reserved}       &0x03\footnote{Code 0x03 is reserved to allow backward compatible support of the 
2993                                        DW\_LNE\_define\_file operation which was defined in \DWARFVersionIV{} 
2994                                        and earlier.} \\
2995 \DWLNEsetdiscriminator  &0x04 \\
2996 \DWLNElouser            &0x80 \\
2997 \DWLNEhiuser            &\xff \\
2998
2999 \end{longtable}
3000 \end{centering}
3001
3002 \clearpage
3003 \needspace{6cm}
3004 The encodings for the line number header entry formats are given in 
3005 \addtoindexx{line number opcodes!file entry format encoding}
3006 Table \refersec{tab:linenumberheaderentryformatencodings}.
3007
3008 \begin{centering}
3009 \setlength{\extrarowheight}{0.1cm}
3010 \begin{longtable}{l|c}
3011   \caption{Line number header entry format \mbox{encodings}} \label{tab:linenumberheaderentryformatencodings}\\
3012   \hline \bfseries Line number header entry format name&\bfseries Value \\ \hline
3013 \endfirsthead
3014   \bfseries Line number header entry format name&\bfseries Value\\ \hline
3015 \endhead
3016   \hline \emph{Continued on next page}
3017 \endfoot
3018   \hline \ddag~\textit{New in DWARF Version 5}
3019 \endlastfoot
3020 \DWLNCTpath~\ddag           & 0x1 \\
3021 \DWLNCTdirectoryindex~\ddag & 0x2 \\
3022 \DWLNCTtimestamp~\ddag      & 0x3 \\
3023 \DWLNCTsize~\ddag           & 0x4 \\
3024 \DWLNCTMDfive~\ddag         & 0x5 \\
3025 \DWLNCTlouser~\ddag         & 0x2000 \\
3026 \DWLNCThiuser~\ddag         & \xiiifff \\
3027 \end{longtable}
3028 \end{centering}
3029
3030 \section{Macro Information}
3031 \label{datarep:macroinformation}
3032 The \addtoindexi{version number}{version number!macro information}
3033 in the macro information header is \versiondotdebugmacro{}
3034 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}). 
3035
3036 The source line numbers and source file indices encoded in the
3037 macro information section are represented as 
3038 unsigned LEB128\addtoindexx{LEB128!unsigned} numbers.
3039
3040 \needlines{4}
3041 The macro information entry type is encoded as a single unsigned byte. 
3042 The encodings 
3043 \addtoindexx{macro information entry types!encoding}
3044 are given in 
3045 Table \refersec{tab:macroinfoentrytypeencodings}.
3046
3047 \needlines{10}
3048 \begin{centering}
3049 \setlength{\extrarowheight}{0.1cm}
3050 \begin{longtable}{l|c}
3051   \caption{Macro information entry type encodings} \label{tab:macroinfoentrytypeencodings}\\
3052   \hline \bfseries Macro information entry type name&\bfseries Value \\ \hline
3053 \endfirsthead
3054   \bfseries Macro information entry type name&\bfseries Value\\ \hline
3055 \endhead
3056   \hline \emph{Continued on next page}
3057 \endfoot
3058   \hline \ddag~\textit{New in DWARF Version 5}
3059 \endlastfoot
3060
3061 \DWMACROdefine~\ddag              &0x01 \\
3062 \DWMACROundef~\ddag               &0x02 \\
3063 \DWMACROstartfile~\ddag           &0x03 \\
3064 \DWMACROendfile~\ddag             &0x04 \\
3065 \DWMACROdefineindirect~\ddag      &0x05 \\
3066 \DWMACROundefindirect~\ddag       &0x06 \\
3067 \DWMACROtransparentinclude~\ddag  &0x07 \\
3068 \DWMACROdefineindirectsup~\ddag   &0x08 \\
3069 \DWMACROundefindirectsup~\ddag    &0x09 \\
3070 \DWMACROtransparentincludesup~\ddag&0x0a \\
3071 \DWMACROdefineindirectx~\ddag     &0x0b \\
3072 \DWMACROundefindirectx~\ddag      &0x0c \\
3073 \DWMACROlouser~\ddag              &0xe0 \\
3074 \DWMACROhiuser~\ddag              &\xff \\
3075
3076 \end{longtable}
3077 \end{centering}
3078
3079 \needlines{7}
3080 \section{Call Frame Information}
3081 \label{datarep:callframeinformation}
3082
3083 In the \thirtytwobitdwarfformat, the value of the CIE id in the
3084 CIE header is \xffffffff; in the \sixtyfourbitdwarfformat, the
3085 value is \xffffffffffffffff.
3086
3087 The value of the CIE \addtoindexi{version number}{version number!call frame information}
3088 is 4 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}). 
3089
3090 Call frame instructions are encoded in one or more bytes. The
3091 primary opcode is encoded in the high order two bits of
3092 the first byte (that is, opcode = byte $\gg$ 6). An operand
3093 or extended opcode may be encoded in the low order 6
3094 bits. Additional operands are encoded in subsequent bytes.
3095 The instructions and their encodings are presented in
3096 Table \refersec{tab:callframeinstructionencodings}.
3097
3098 \begin{centering}
3099 \setlength{\extrarowheight}{0.1cm}
3100 \begin{longtable}{l|c|c|l|l}
3101   \caption{Call frame instruction encodings} \label{tab:callframeinstructionencodings} \\
3102   \hline &\bfseries High 2 &\bfseries Low 6 &  & \\
3103   \bfseries Instruction&\bfseries Bits &\bfseries Bits &\bfseries Operand 1 &\bfseries Operand 2\\ \hline
3104 \endfirsthead
3105    & \bfseries High 2 &\bfseries Low 6 &  &\\
3106   \bfseries Instruction&\bfseries Bits &\bfseries Bits &\bfseries Operand 1 &\bfseries Operand 2\\ \hline
3107 \endhead
3108   \hline \emph{Continued on next page}
3109 \endfoot
3110   \hline
3111 \endlastfoot
3112
3113 \DWCFAadvanceloc&0x1&delta & \\
3114 \DWCFAoffset&0x2&register&ULEB128 offset \\
3115 \DWCFArestore&0x3&register & & \\
3116 \DWCFAnop&0&0 & & \\
3117 \DWCFAsetloc&0&0x01&address & \\
3118 \DWCFAadvancelocone&0&0x02&1\dash byte delta & \\
3119 \DWCFAadvanceloctwo&0&0x03&2\dash byte delta & \\
3120 \DWCFAadvancelocfour&0&0x04&4\dash byte delta & \\
3121 \DWCFAoffsetextended&0&0x05&ULEB128 register&ULEB128 offset \\
3122 \DWCFArestoreextended&0&0x06&ULEB128 register & \\
3123 \DWCFAundefined&0&0x07&ULEB128 register & \\
3124 \DWCFAsamevalue&0&0x08 &ULEB128 register & \\
3125 \DWCFAregister&0&0x09&ULEB128 register &ULEB128 offset \\
3126 \DWCFArememberstate&0&0x0a & & \\
3127 \DWCFArestorestate&0&0x0b & & \\
3128 \DWCFAdefcfa&0&0x0c &ULEB128 register&ULEB128 offset \\
3129 \DWCFAdefcfaregister&0&0x0d&ULEB128 register & \\
3130 \DWCFAdefcfaoffset&0&0x0e &ULEB128 offset & \\
3131 \DWCFAdefcfaexpression&0&0x0f &BLOCK  \\
3132 \DWCFAexpression&0&0x10&ULEB128 register & BLOCK \\
3133
3134 \DWCFAoffsetextendedsf&0&0x11&ULEB128 register&SLEB128 offset \\
3135 \DWCFAdefcfasf&0&0x12&ULEB128 register&SLEB128 offset \\
3136 \DWCFAdefcfaoffsetsf&0&0x13&SLEB128 offset & \\
3137 \DWCFAvaloffset&0&0x14&ULEB128&ULEB128 \\
3138 \DWCFAvaloffsetsf&0&0x15&ULEB128&SLEB128 \\
3139 \DWCFAvalexpression&0&0x16&ULEB128&BLOCK  \\
3140 \DWCFAlouser&0&0x1c   & & \\
3141 \DWCFAhiuser&0&\xiiif & & \\
3142 \end{longtable}
3143 \end{centering}
3144
3145 \section{Non-contiguous Address Ranges}
3146 \label{datarep:noncontiguousaddressranges}
3147
3148 Each entry in a \addtoindex{range list}
3149 (see Section \refersec{chap:noncontiguousaddressranges})
3150 is either a
3151 \addtoindexx{base address selection entry!in range list}
3152 range list entry, 
3153 \addtoindexx{range list}
3154 a base address selection entry, or an end-of-list entry.
3155
3156 A \addtoindex{range list} entry consists of two relative addresses. The
3157 addresses are the same size as addresses on the target machine.
3158
3159 \needlines{4}
3160 A base address selection entry and an 
3161 \addtoindexx{end-of-list entry!in range list}
3162 end-of-list entry each
3163 \addtoindexx{base address selection entry!in range list}
3164 consist of two (constant or relocated) addresses. The two
3165 addresses are the same size as addresses on the target machine.
3166
3167 For a \addtoindex{range list} to be specified, the base address of the
3168 \addtoindexx{base address selection entry!in range list}
3169 corresponding compilation unit must be defined 
3170 (see Section \refersec{chap:normalandpartialcompilationunitentries}).
3171
3172 \needlines{6}
3173 \section{String Offsets Table}
3174 \label{chap:stringoffsetstable}
3175 Each set of entries in the string offsets table contained in the
3176 \dotdebugstroffsets{} or \dotdebugstroffsetsdwo{}
3177 section begins with a header containing:
3178 \begin{enumerate}[1. ]
3179 \item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
3180 \addttindexx{unit\_length}
3181 A 4-byte or 12-byte length containing the length of
3182 the set of entries for this compilation unit, not
3183 including the length field itself. In the 32-bit
3184 DWARF format, this is a 4-byte unsigned integer
3185 (which must be less than \xfffffffzero); in the 64-bit
3186 DWARF format, this consists of the 4-byte value
3187 \wffffffff followed by an 8-byte unsigned integer
3188 that gives the actual length (see 
3189 Section \refersec{datarep:32bitand64bitdwarfformats}).
3190
3191 %\needlines{4}
3192 \item  \texttt{version} (\addtoindex{uhalf}) \\
3193 A 2-byte version identifier containing the value
3194 \versiondotdebugstroffsets{} 
3195 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
3196
3197 \item \texttt{padding} (\addtoindex{uhalf}) \\
3198 \end{enumerate}
3199
3200 This header is followed by a series of string table offsets
3201 that have the same representation as \DWFORMstrp.
3202 For the 32-bit DWARF format, each offset is 4 bytes long; for
3203 the 64-bit DWARF format, each offset is 8 bytes long.
3204
3205 The \DWATstroffsetsbase{} attribute points to the first
3206 entry following the header. The entries are indexed
3207 sequentially from this base entry, starting from 0.
3208
3209 \section{Address Table}
3210 \label{chap:addresstable}
3211 Each set of entries in the address table contained in the
3212 \dotdebugaddr{} section begins with a header containing:
3213 \begin{enumerate}[1. ]
3214 \item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
3215 \addttindexx{unit\_length}
3216 A 4-byte or 12-byte length containing the length of
3217 the set of entries for this compilation unit, not
3218 including the length field itself. In the 32-bit
3219 DWARF format, this is a 4-byte unsigned integer
3220 (which must be less than \xfffffffzero); in the 64-bit
3221 DWARF format, this consists of the 4-byte value
3222 \wffffffff followed by an 8-byte unsigned integer
3223 that gives the actual length (see 
3224 Section \refersec{datarep:32bitand64bitdwarfformats}).
3225
3226 \needlines{4}
3227 \item  \texttt{version} (\addtoindex{uhalf}) \\
3228 A 2-byte version identifier containing the value
3229 \versiondotdebugaddr{} 
3230 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
3231
3232 \needlines{4}
3233 \item   \texttt{address\_size} (\addtoindex{ubyte}) \\
3234 A 1-byte unsigned integer containing the size in
3235 bytes of an address (or the offset portion of an
3236 address for segmented addressing) on the target
3237 system.
3238
3239 \needlines{4}
3240 \item   \texttt{segment\_size} (\addtoindex{ubyte}) \\
3241 A 1-byte unsigned integer containing the size in
3242 bytes of a segment selector on the target system.
3243 \end{enumerate}
3244
3245 This header is followed by a series of segment/address pairs.
3246 The segment size is given by the \addttindex{segment\_size} field of the
3247 header, and the address size is given by the \addttindex{address\_size}
3248 field of the header. If the \addttindex{segment\_size} field in the header
3249 is zero, the entries consist only of an addresses.
3250
3251 The \DWATaddrbase{} attribute points to the first entry
3252 following the header. The entries are indexed sequentially
3253 from this base entry, starting from 0.
3254
3255 \section{Range List Table}
3256 \label{app:rangelisttable}
3257 Each set of entries in the range list table contained in the
3258 \dotdebugranges{} section begins with a header containing:
3259 \begin{enumerate}[1. ]
3260 \item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
3261 \addttindexx{unit\_length}
3262 A 4-byte or 12-byte length containing the length of
3263 the set of entries for this compilation unit, not
3264 including the length field itself. In the 32-bit
3265 DWARF format, this is a 4-byte unsigned integer
3266 (which must be less than \xfffffffzero); in the 64-bit
3267 DWARF format, this consists of the 4-byte value
3268 \wffffffff followed by an 8-byte unsigned integer
3269 that gives the actual length (see 
3270 Section \refersec{datarep:32bitand64bitdwarfformats}).
3271
3272 \needlines{4}
3273 \item  \texttt{version} (\addtoindex{uhalf}) \\
3274 A 2-byte version identifier containing the value
3275 \versiondotdebugranges{} 
3276 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
3277
3278 \needlines{4}
3279 \item   \texttt{address\_size} (\addtoindex{ubyte}) \\
3280 A 1-byte unsigned integer containing the size in
3281 bytes of an address (or the offset portion of an
3282 address for segmented addressing) on the target
3283 system.
3284
3285 \needlines{4}
3286 \item   \texttt{segment\_size} (\addtoindex{ubyte}) \\
3287 A 1-byte unsigned integer containing the size in
3288 bytes of a segment selector on the target system.
3289 \end{enumerate}
3290
3291 This header is followed by a series of range list entries as
3292 described in Section \refersec{chap:noncontiguousaddressranges}.
3293 The segment size is given by the
3294 \addttindex{segment\_size} field of the header, and the address size is
3295 given by the \addttindex{address\_size} field of the header. If the
3296 \addttindex{segment\_size} field in the header is zero, the segment
3297 selector is omitted from the range list entries.
3298
3299 The \DWATrangesbase{} attribute points to the first entry
3300 following the header. The entries are referenced by a byte
3301 offset relative to this base address.
3302
3303
3304 \section{Location List Table}
3305 \label{datarep:locationlisttable}
3306 Each set of entries in the location list table contained in the
3307 \dotdebugloc{} or \dotdebuglocdwo{} sections begins with a header containing:
3308 \begin{enumerate}[1. ]
3309 \item \texttt{unit\_length} (\livelink{datarep:initiallengthvalues}{initial length}) \\
3310 \addttindexx{unit\_length}
3311 A 4-byte or 12-byte length containing the length of
3312 the set of entries for this compilation unit, not
3313 including the length field itself. In the 32-bit
3314 DWARF format, this is a 4-byte unsigned integer
3315 (which must be less than \xfffffffzero); in the 64-bit
3316 DWARF format, this consists of the 4-byte value
3317 \wffffffff followed by an 8-byte unsigned integer
3318 that gives the actual length (see 
3319 Section \refersec{datarep:32bitand64bitdwarfformats}).
3320
3321 \needlines{4}
3322 \item  \texttt{version} (\addtoindex{uhalf}) \\
3323 A 2-byte version identifier containing the value
3324 \versiondotdebugloc{} 
3325 (see Appendix \refersec{app:dwarfsectionversionnumbersinformative}).
3326
3327 \needlines{5}
3328 \item   \texttt{address\_size} (\addtoindex{ubyte}) \\
3329 A 1-byte unsigned integer containing the size in
3330 bytes of an address (or the offset portion of an
3331 address for segmented addressing) on the target
3332 system.
3333
3334 \needlines{4}
3335 \item   \texttt{segment\_size} (\addtoindex{ubyte}) \\
3336 A 1-byte unsigned integer containing the size in
3337 bytes of a segment selector on the target system.
3338 \end{enumerate}
3339
3340 This header is followed by a series of location list entries as
3341 described in Section \refersec{chap:locationlists}.
3342 The segment size is given by the
3343 \addttindex{segment\_size} field of the header, and the address size is
3344 given by the \texttt{address\_size} field of the header. If the
3345 \addttindex{segment\_size} field in the header is zero, the segment
3346 selector is omitted from the range list entries.
3347
3348 The entries are referenced by a byte offset relative to the first
3349 location list following this header.
3350
3351 \needlines{6}
3352 \section{Dependencies and Constraints}
3353 \label{datarep:dependenciesandconstraints}
3354 The debugging information in this format is intended to
3355 exist 
3356 \addtoindexx{DWARF section names!list of}
3357 in the
3358 \dotdebugabbrev{},
3359 \dotdebugaddr{}, 
3360 \dotdebugaranges{}, 
3361 \dotdebugframe{},
3362 \dotdebuginfo{}, 
3363 \dotdebugline{}, 
3364 \dotdebuglinestr{},
3365 \dotdebugloc{}, 
3366 \dotdebugmacro{},
3367 \dotdebugnames{}, 
3368 \dotdebugranges{}, 
3369 \dotdebugstr{},
3370 and
3371 \dotdebugstroffsets{}
3372 sections of an object file, or equivalent
3373 separate file or database. The information is not 
3374 word\dash aligned. Consequently:
3375
3376 \begin{itemize}
3377 \item For the \thirtytwobitdwarfformat{} and a target architecture with
3378 32\dash bit addresses, an assembler or compiler must provide a way
3379 to produce 2\dash byte and 4\dash byte quantities without alignment
3380 restrictions, and the linker must be able to relocate a
3381 4\dash byte address or 
3382 \addtoindexx{section offset!alignment of}
3383 section offset that occurs at an arbitrary
3384 alignment.
3385
3386 \item For the \thirtytwobitdwarfformat{} and a target architecture with
3387 64\dash bit addresses, an assembler or compiler must provide a
3388 way to produce 2\dash byte, 4\dash byte and 8\dash byte quantities without
3389 alignment restrictions, and the linker must be able to relocate
3390 an 8\dash byte address or 4\dash byte 
3391 \addtoindexx{section offset!alignment of}
3392 section offset that occurs at an
3393 arbitrary alignment.
3394
3395 \item For the \sixtyfourbitdwarfformat{} and a target architecture with
3396 32\dash bit addresses, an assembler or compiler must provide a
3397 way to produce 2\dash byte, 4\dash byte and 8\dash byte quantities without
3398 alignment restrictions, and the linker must be able to relocate
3399 a 4\dash byte address or 8\dash byte 
3400 \addtoindexx{section offset!alignment of}
3401 section offset that occurs at an
3402 arbitrary alignment.
3403
3404 \textit{It is expected that this will be required only for very large
3405 32\dash bit programs or by those architectures which support
3406 a mix of 32\dash bit and 64\dash bit code and data within the same
3407 executable object.}
3408
3409 \item For the \sixtyfourbitdwarfformat{} and a target architecture with
3410 64\dash bit addresses, an assembler or compiler must provide a
3411 way to produce 2\dash byte, 4\dash byte and 8\dash byte quantities without
3412 alignment restrictions, and the linker must be able to
3413 relocate an 8\dash byte address or 
3414 \addtoindexx{section offset!alignment of}
3415 section offset that occurs at
3416 an arbitrary alignment.
3417 \end{itemize}
3418
3419 \needlines{8}
3420 \section{Integer Representation Names}
3421 \label{datarep:integerrepresentationnames}
3422 The sizes of the integers used in the lookup by name, lookup
3423 by address, line number, call frame information and other sections
3424 are given in
3425 Table \ref{tab:integerrepresentationnames}.
3426
3427 \needlines{12}
3428 \begin{centering}
3429 \setlength{\extrarowheight}{0.1cm}
3430 \begin{longtable}{c|l}
3431   \caption{Integer representation names} \label{tab:integerrepresentationnames}\\
3432   \hline \bfseries Representation name&\bfseries Representation \\ \hline
3433 \endfirsthead
3434   \bfseries Representation name&\bfseries Representation\\ \hline
3435 \endhead
3436   \hline \emph{Continued on next page}
3437 \endfoot
3438   \hline
3439 \endlastfoot
3440
3441 \addtoindex{sbyte}&  signed, 1\dash byte integer \\
3442 \addtoindex{ubyte}&unsigned, 1\dash byte integer \\
3443 \addtoindex{uhalf}&unsigned, 2\dash byte integer \\
3444 \addtoindex{uword}&unsigned, 4\dash byte integer \\
3445
3446 \end{longtable}
3447 \end{centering}
3448
3449 \needlines{6}
3450 \section{Type Signature Computation}
3451 \label{datarep:typesignaturecomputation}
3452
3453 A type signature is computed only by the DWARF producer;
3454 \addtoindexx{type signature!computation}
3455 it is used by a DWARF consumer to resolve type references to
3456 the type definitions that are contained in 
3457 \addtoindexx{type unit}
3458 type units.
3459
3460 \needlines{4}
3461 The type signature for a type T0 is formed from the 
3462 \MDfive{}\footnote{\livetarg{def:MDfive}{MD5} Message Digest Algorithm, 
3463 R.L. Rivest, RFC 1321, April 1992}
3464 hash of a flattened description of the type. The flattened
3465 description of the type is a byte sequence derived from the
3466 DWARF encoding of the type as follows:
3467 \begin{enumerate}[1. ]
3468
3469 \item Start with an empty sequence S and a list V of visited
3470 types, where V is initialized to a list containing the type
3471 T0 as its single element. Elements in V are indexed from 1,
3472 so that V[1] is T0.
3473
3474 \item If the debugging information entry represents a type that
3475 is nested inside another type or a namespace, append to S
3476 the type\textquoteright s context as follows: For each surrounding type
3477 or namespace, beginning with the outermost such construct,
3478 append the letter 'C', the DWARF tag of the construct, and
3479 the name (taken from 
3480 \addtoindexx{name attribute}
3481 the \DWATname{} attribute) of the type
3482 \addtoindexx{name attribute}
3483 or namespace (including its trailing null byte).
3484
3485 \item  Append to S the letter 'D', followed by the DWARF tag of
3486 the debugging information entry.
3487
3488 \item For each of the attributes in
3489 Table \refersec{tab:attributesusedintypesignaturecomputation}
3490 that are present in
3491 the debugging information entry, in the order listed,
3492 append to S a marker letter (see below), the DWARF attribute
3493 code, and the attribute value.
3494
3495 \begin{table}[ht]
3496 \caption{Attributes used in type signature computation}
3497 \label{tab:attributesusedintypesignaturecomputation}
3498 \simplerule[\textwidth]
3499 \begin{center}
3500 \autocols[0pt]{c}{2}{l}{
3501 \DWATname,
3502 \DWATaccessibility,
3503 \DWATaddressclass,
3504 \DWATalignment,
3505 \DWATallocated,
3506 \DWATartificial,
3507 \DWATassociated,
3508 \DWATbinaryscale,
3509 %\DWATbitoffset,
3510 \DWATbitsize,
3511 \DWATbitstride,
3512 \DWATbytesize,
3513 \DWATbytestride,
3514 \DWATconstexpr,
3515 \DWATconstvalue,
3516 \DWATcontainingtype,
3517 \DWATcount,
3518 \DWATdatabitoffset,
3519 \DWATdatalocation,
3520 \DWATdatamemberlocation,
3521 \DWATdecimalscale,
3522 \DWATdecimalsign,
3523 \DWATdefaultvalue,
3524 \DWATdigitcount,
3525 \DWATdiscr,
3526 \DWATdiscrlist,
3527 \DWATdiscrvalue,
3528 \DWATencoding,
3529 \DWATenumclass,
3530 \DWATendianity,
3531 \DWATexplicit,
3532 \DWATisoptional,
3533 \DWATlocation,
3534 \DWATlowerbound,
3535 \DWATmutable,
3536 \DWATordering,
3537 \DWATpicturestring,
3538 \DWATprototyped,
3539 \DWATrank,
3540 \DWATreference,
3541 \DWATrvaluereference,
3542 \DWATsmall,
3543 \DWATsegment,
3544 \DWATstringlength,
3545 \DWATstringlengthbitsize,
3546 \DWATstringlengthbytesize,
3547 \DWATthreadsscaled,
3548 \DWATupperbound,
3549 \DWATuselocation,
3550 \DWATuseUTFeight,
3551 \DWATvariableparameter,
3552 \DWATvirtuality,
3553 \DWATvisibility,
3554 \DWATvtableelemlocation
3555 }
3556 \end{center}
3557 \simplerule[\textwidth]
3558 \end{table}
3559
3560 Note that except for the initial 
3561 \DWATname{} attribute,
3562 \addtoindexx{name attribute}
3563 attributes are appended in order according to the alphabetical
3564 spelling of their identifier.
3565
3566 If an implementation defines any vendor-specific attributes,
3567 any such attributes that are essential to the definition of
3568 the type should also be included at the end of the above list,
3569 in their own alphabetical suborder.
3570
3571 An attribute that refers to another type entry T is processed
3572 as follows: (a) If T is in the list V at some V[x], use the
3573 letter 'R' as the marker and use the unsigned LEB128\addtoindexx{LEB128!unsigned}
3574 encoding of x as the attribute value; otherwise, (b) use the letter 'T'
3575 as the marker, process the type T recursively by performing
3576 Steps 2 through 7, and use the result as the attribute value.
3577
3578 Other attribute values use the letter 'A' as the marker, and
3579 the value consists of the form code (encoded as an unsigned
3580 LEB128 value) followed by the encoding of the value according
3581 to the form code. To ensure reproducibility of the signature,
3582 the set of forms used in the signature computation is limited
3583 to the following: 
3584 \DWFORMsdata, 
3585 \DWFORMflag, 
3586 \DWFORMstring,
3587 \DWFORMexprloc,
3588 and \DWFORMblock.
3589
3590 \needlines{4}
3591 \item If the tag in Step 3 is one of \DWTAGpointertype,
3592 \DWTAGreferencetype, 
3593 \DWTAGrvaluereferencetype,
3594 \DWTAGptrtomembertype, 
3595 or \DWTAGfriend, and the referenced
3596 type (via the \DWATtype{} or 
3597 \DWATfriend{} attribute) has a
3598 \DWATname{} attribute, append to S the letter 'N', the DWARF
3599 attribute code (\DWATtype{} or 
3600 \DWATfriend), the context of
3601 the type (according to the method in Step 2), the letter 'E',
3602 and the name of the type. For \DWTAGfriend, if the referenced
3603 entry is a \DWTAGsubprogram, the context is omitted and the
3604 name to be used is the ABI-specific name of the subprogram
3605 (for example, the mangled linker name).
3606
3607
3608 \item If the tag in Step 3 is not one of \DWTAGpointertype,
3609 \DWTAGreferencetype, 
3610 \DWTAGrvaluereferencetype,
3611 \DWTAGptrtomembertype, or 
3612 \DWTAGfriend, but has
3613 a \DWATtype{} attribute, or if the referenced type (via
3614 the \DWATtype{} or 
3615 \DWATfriend{} attribute) does not have a
3616 \DWATname{} attribute, the attribute is processed according to
3617 the method in Step 4 for an attribute that refers to another
3618 type entry.
3619
3620
3621 \item Visit each child C of the debugging information
3622 entry as follows: If C is a nested type entry or a member
3623 function entry, and has 
3624 a \DWATname{} attribute, append to
3625 \addtoindexx{name attribute}
3626 S the letter 'S', the tag of C, and its name; otherwise,
3627 process C recursively by performing Steps 3 through 7,
3628 appending the result to S. Following the last child (or if
3629 there are no children), append a zero byte.
3630 \end{enumerate}
3631
3632
3633
3634 For the purposes of this algorithm, if a debugging information
3635 entry S has a 
3636 \DWATspecification{} 
3637 attribute that refers to
3638 another entry D (which has a 
3639 \DWATdeclaration{} 
3640 attribute),
3641 then S inherits the attributes and children of D, and S is
3642 processed as if those attributes and children were present in
3643 the entry S. Exception: if a particular attribute is found in
3644 both S and D, the attribute in S is used and the corresponding
3645 one in D is ignored.
3646
3647 \needlines{4}
3648 DWARF tag and attribute codes are appended to the sequence
3649 as unsigned LEB128\addtoindexx{LEB128!unsigned} values, 
3650 using the values defined earlier in this chapter.
3651
3652 \textit{A grammar describing this computation may be found in
3653 Appendix \refersec{app:typesignaturecomputationgrammar}.
3654 }
3655
3656 \textit{An attribute that refers to another type entry should
3657 be recursively processed or replaced with the name of the
3658 referent (in Step 4, 5 or 6). If neither treatment applies to
3659 an attribute that references another type entry, the entry
3660 that contains that attribute should not be considered for a
3661 separate \addtoindex{type unit}.}
3662
3663 \textit{If a debugging information entry contains an attribute from
3664 the list above that would require an unsupported form, that
3665 entry should not be considered for a separate 
3666 \addtoindex{type unit}.}
3667
3668 \textit{A type should be considered for a separate 
3669 \addtoindex{type unit} only
3670 if all of the type entries that it contains or refers to in
3671 Steps 6 and 7 can themselves each be considered for a separate
3672 \addtoindex{type unit}.}
3673
3674 \needlines{4}
3675 Where the DWARF producer may reasonably choose two or more
3676 different forms for a given attribute, it should choose
3677 the simplest possible form in computing the signature. (For
3678 example, a constant value should be preferred to a location
3679 expression when possible.)
3680
3681 Once the string S has been formed from the DWARF encoding,
3682 an \MDfive{} hash is computed for the string and the 
3683 least significant 64 bits are taken as the type signature.
3684
3685 \textit{The string S is intended to be a flattened representation of
3686 the type that uniquely identifies that type (that is, a different
3687 type is highly unlikely to produce the same string).}
3688
3689 \needlines{6}
3690 \textit{A debugging information entry should not be placed in a
3691 separate \addtoindex{type unit}
3692 if any of the following apply:}
3693
3694 \begin{itemize}
3695
3696 \item \textit{The entry has an attribute whose value is a location
3697 expression, and the location expression contains a reference to
3698 another debugging information entry (for example, a \DWOPcallref{}
3699 operator), as it is unlikely that the entry will remain
3700 identical across compilation units.}
3701
3702 \item \textit{The entry has an attribute whose value refers
3703 to a code location or a \addtoindex{location list}.}
3704
3705 \item \textit{The entry has an attribute whose value refers
3706 to another debugging information entry that does not represent
3707 a type.}
3708 \end{itemize}
3709
3710
3711 \needlines{4}
3712 \textit{Certain attributes are not included in the type signature:}
3713
3714 \begin{itemize}
3715 \item \textit{The \DWATdeclaration{} attribute is not included because it
3716 indicates that the debugging information entry represents an
3717 incomplete declaration, and incomplete declarations should
3718 not be placed in 
3719 \addtoindexx{type unit}
3720 separate type units.}
3721
3722 \item \textit{The \DWATdescription{} attribute is not included because
3723 it does not provide any information unique to the defining
3724 declaration of the type.}
3725
3726 \item \textit{The \DWATdeclfile, 
3727 \DWATdeclline, and
3728 \DWATdeclcolumn{} attributes are not included because they
3729 may vary from one source file to the next, and would prevent
3730 two otherwise identical type declarations from producing the
3731 same \MDfive{} hash.}
3732
3733 \item \textit{The \DWATobjectpointer{} attribute is not included 
3734 because the information it provides is not necessary for the 
3735 computation of a unique type signature.}
3736
3737 \end{itemize}
3738
3739 \textit{Nested types and some types referred to by a debugging 
3740 information entry are encoded by name rather than by recursively 
3741 encoding the type to allow for cases where a complete definition 
3742 of the type might not be available in all compilation units.}
3743
3744 \needlines{4}
3745 \textit{If a type definition contains the definition of a member function, 
3746 it cannot be moved as is into a type unit, because the member function 
3747 contains attributes that are unique to that compilation unit. 
3748 Such a type definition can be moved to a type unit by rewriting the DIE tree, 
3749 moving the member function declaration into a separate declaration tree, 
3750 and replacing the function definition in the type with a non-defining 
3751 declaration of the function (as if the function had been defined out of 
3752 line).}
3753
3754 An example that illustrates the computation of an \MDfive{} hash may be found in 
3755 Appendix \refersec{app:usingtypeunits}.
3756