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