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