This submission corresponds to the March 7, 2016 version released
[dwarf-doc.git] / dwarf5 / latexdoc / splitobjects.tex
1 \chapter[Split DWARF Object Files (Informative)]{Split DWARF Object Files (Informative)}
2 \label{app:splitdwarfobjectsinformative}
3 \addtoindexx{DWARF compression}
4 \addtoindexx{DWARF duplicate elimination|see{\textit{also} DWARF compression}}
5 \addtoindexx{DWARF duplicate elimination|see{\textit{also} split DWARF object file}}
6 With the traditional DWARF format, debug information is designed
7 with the expectation that it will be processed by the linker to
8 produce an output binary with complete debug information, and
9 with fully-resolved references to locations within the
10 application. For very large applications, however, this approach
11 can result in excessively large link times and excessively large
12 output files. 
13
14 Several vendors have independently developed
15 proprietary approaches that allow the debug information to remain
16 in the relocatable object files, so that the linker does not have
17 to process the debug information or copy it to the output file.
18 These approaches have all required that additional information be
19 made available to the debug information consumer, and that the
20 consumer perform some minimal amount of relocation in order to
21 interpret the debug info correctly. The additional information
22 required, in the form of load maps or symbol tables, and the
23 details of the relocation are not covered by the DWARF
24 specification, and vary with each vendor's implementation.
25
26 Section \refersec{datarep:splitdwarfobjectfiles} describes a
27 platform-independent mechanism that allows a producer to
28 split the debugging information into relocatable and
29 non-relocatable partitions. This Appendix describes the use
30 of \splitDWARFobjectfile{s} and provides some illustrative
31 examples.
32
33 \section{Overview}
34 \label{app:splitoverview}
35 \DWARFVersionV{} introduces an optional set of debugging sections
36 that allow the compiler to partition the debugging information
37 into a set of (small) sections that require link-time relocation
38 and a set of (large) sections that do not. The sections that
39 require relocation are written to the relocatable object file as
40 usual, and are linked into the final executable. The sections
41 that do not require relocation, however, can be written to the
42 relocatable object (.o) file but ignored by the linker, or they
43 can be written to a separate DWARF object (.dwo{}) 
44 \addtoindexx{\texttt{.dwo} file extension} file.
45
46 \needlines{4}
47 The optional set of debugging sections includes the following:
48 \begin{itemize}
49 \bb
50 \item
51 \dotdebugabbrevdwo{} - Contains the abbreviations table(s) used by
52 the \dotdebuginfodwo{} section.
53 \eb
54 \item
55 \dotdebuginfodwo{} - Contains the \DWTAGcompileunit{} and
56 \DWTAGtypeunit{} DIEs and
57 their descendants. This is the bulk of the debugging
58 information for the compilation unit that is normally found
59 in the \dotdebuginfo{} section.
60 \bbeb
61 \item
62 \dotdebuglocdwo{} - Contains the location lists referenced by
63 the debugging information entries in the \dotdebuginfodwo{}
64 section. This contains the location lists normally found in 
65 the \dotdebugloc{} section, with a 
66 \bbeb 
67 modified format to eliminate the need for relocations.
68 \item
69 \dotdebugstrdwo{} - Contains the string table for all indirect
70 strings referenced by the debugging information in the
71 \dotdebuginfodwo{} sections.
72 \item
73 \dotdebugstroffsetsdwo{} - Contains the string offsets table
74 for the strings in the \dotdebugstrdwo{}{} section.
75 \item
76 \dotdebugmacrodwo{} - Contains macro definition information,
77 normally found in the \dotdebugmacro{} section.
78 \item
79 \dotdebuglinedwo{} - Contains \addtoindex{specialized line number table}s 
80 for the type units in the \dotdebuginfodwo{} section. These tables
81 contain only the directory and filename lists needed to
82 interpret \DWATdeclfile{} attributes in the debugging
83 information entries. Actual line number tables remain in the
84 \dotdebugline{} section, and remain in the relocatable object
85 (.o) files.
86
87 \end{itemize}
88
89 In a \texttt{.dwo} file, there is no benefit to having a separate string
90 section for directories and file names because the primary
91 string table will never be stripped. Accordingly, no
92 \texttt{.debug\_line\_str.dwo} section is defined. Content descriptions 
93 corresponding to \DWFORMlinestrp{} in an executable file (for example, 
94 in the skeleton compilation unit) instead use \DWFORMstrx. This allows
95 directory and file name strings to be merged with general
96 strings and across compilations in package files 
97 \bb
98 (where they
99 \eb
100 are not subject to potential stripping).
101
102 In a \texttt{.dwo} file, referring to a string using \DWFORMstrp{}
103 is valid, but such use 
104 \bb
105 results in a file that cannot be incorporated into a package file
106 (which involves string merging).
107 \eb
108
109 In order for the consumer to locate and process the debug
110 information, the compiler must produce a small amount of debug
111 information that passes through the linker into the output
112 binary. A skeleton \dotdebuginfo{} section for each compilation unit
113 contains a reference to the corresponding \texttt{.o} or \texttt{.dwo}
114 file, and the \dotdebugline{} section (which is typically small
115 compared to the \dotdebuginfo{} sections) is
116 linked into the output binary, as is the new \dotdebugaddr{}
117 section.
118
119 \needlines{6}
120 The debug sections that continue to be linked into the
121 output binary include the following:
122 \begin{itemize}
123 \item
124 \dotdebugabbrev{} - Contains the abbreviation codes used by the
125 skeleton \dotdebuginfo{} section.
126 \bb
127 \item
128 \dotdebugaddr{} - Contains references to loadable sections,
129 indexed by attributes of form \DWFORMaddrx{} or location
130 \bb
131 expression 
132 \eb
133 \DWOPaddrx{} opcodes.
134 \item
135 \dotdebugaranges{} - Contains the accelerated range lookup table
136 for the compilation unit.
137 \item
138 \dotdebugframe{} - Contains the frame tables.
139 \item
140 \dotdebuginfo{} - Contains a skeleton \DWTAGcompileunit{} DIE,
141 but no children.
142 \item
143 \dotdebugline{} - Contains the line number tables.
144 (These could be moved to the .dwo file, but in
145 order to do so, each \DWLNEsetaddress{} opcode would need to
146 be replaced by a new opcode that referenced an entry in the
147 \dotdebugaddr{} section. Furthermore, leaving this section in the
148 .o file allows many debug info consumers to remain unaware of
149 .dwo files.)
150 \bb
151 \item
152 \dotdebuglinestr{} - Contains strings for file names used in
153 combination with the \dotdebugline{} section.
154 \eb
155 \item
156 \dotdebugnames{} - Contains the names for use in
157 building an index section. 
158 \bbeb
159 The section header refers to a
160 compilation unit offset, which is the offset of the
161 skeleton compilation unit in the \dotdebuginfo{} section.
162 \item
163 \dotdebugranges{} - Contains the range lists.
164 \item
165 \dotdebugstr{} - Contains any strings referenced by the skeleton
166 \dotdebuginfo{} sections (via \DWFORMstrp{} or \DWFORMstrx{}).
167 \item
168 \dotdebugstroffsets{} - Contains the string offsets table for
169 the strings in the \dotdebugstr{} section (if form \DWFORMstrx{} is used).
170 \eb
171 \end{itemize}
172
173 \needlines{6}
174 The skeleton \DWTAGcompileunit{} DIE 
175 \bb
176 may have 
177 \eb
178 the following attributes:
179 \autocols[0pt]{c}{3}{l}{
180 \DWATaddrbase{},
181 \DWATcompdir{},
182 \DWATdwoname{},
183 \DWATdwoid{},
184 \DWAThighpc{},
185 \DWATlowpc{},
186 \DWATranges{},
187 \DWATrangesbase{},
188 \DWATstmtlist{},
189 \DWATstroffsetsbase{}
190 }
191
192 \bbpareb
193
194 All other attributes of the compilation unit DIE are moved to
195 the full DIE in the \dotdebuginfodwo{} section.
196 The \DWATdwoid{} attribute is present
197 in both the skeleton DIE and the full DIE, so that a consumer
198 can verify a match.
199
200 \needlines{4}
201
202 Relocations are neither necessary nor useful in 
203 \bb
204 \texttt{.dwo} files, because the \texttt{.dwo}  
205 \eb
206 files contain only debugging information that does not need to be
207 processed by a linker. Relocations are rendered unnecessary via
208 four strategies:
209
210 \begin{enumerate}[1. ]
211 \item Some values needing relocation are kept in the \texttt{.o} file
212 (for example, references to the line number program from the skeleton
213 compilation unit).
214
215 \item Some values do not need a relocation because they refer from
216 one \dotdwo{} section to another \dotdwo{} section
217 \bb
218 in the same compilation unit. 
219 \eb
220
221 \item Some values that need a relocation to refer to a
222 relocatable program address use the \DWFORMaddrx{} form,
223 referencing a relocatable value in the \dotdebugaddr{} section (which
224 remains in the \texttt{.o} file).
225
226 \item Some values that need a relocation to refer to the
227 \dotdebugranges{} section in the \texttt{.o} file use a relocatable base
228 specified by the \DWATrangesbase{} attribute (which is placed in the
229 skeleton compilation unit in the \texttt{.o} file).
230
231 \end{enumerate}
232
233
234 Table \refersec{tab:unitattributesbyunitkind} summarizes which
235 attributes are defined for use in the various 
236 \bb
237 kinds of compilation units (see Section \refersec{chap:unitentries}). 
238 It compares and contrasts both conventional and split object-related
239 kinds.
240 \eb
241
242
243 \begin{table}[ht]
244 \caption{Unit attributes by unit kind}
245 \label{tab:unitattributesbyunitkind}
246 \begin{tabular}{P{5.5cm}|cc|ccc}
247 \hline
248                         & \multicolumn{5}{c}{\bfseries Unit Kind} \\
249 \bbeb                   & \multicolumn{2}{c}{\bfseries Conventional} 
250                                               & \multicolumn{3}{c}{\bfseries Skeleton and Split} \\
251 \bfseries Attribute     & Full \&    &  Type  &  Skeleton & Split Full & Split Type \\
252                         & Partial    &        &           &            &            \\
253 \hline
254 \DWATaddrbase           & \chkmk  &        &  \chkmk   &        &         \\
255 \hline
256 \DWATbasetypes          & \chkmk  &        &           &        &         \\
257 \hline
258 \DWATcompdir            & \chkmk  &        &  \chkmk   &        &         \\
259 \hline
260 \DWATdwoid              &         &        &  \chkmk   & \chkmk &         \\
261 \hline
262 \DWATdwoname            &         &        &  \chkmk   &        &         \\
263 \hline
264 \DWATentrypc            & \chkmk  &        &           & \chkmk &         \\
265 \hline
266 \bbeb\DWAThighpc             & \chkmk  &        &  \chkmk   &        &         \\
267 \hline
268 \DWATidentifiercase     & \chkmk  &        &           & \chkmk &         \\
269 \hline
270 \DWATlanguage           & \chkmk  & \chkmk &           & \chkmk & \chkmk  \\
271 \hline
272 \bbeb\DWATlowpc              & \chkmk  &        &  \chkmk   &        &         \\
273 \hline
274 \DWATmacros             & \chkmk  &        &           & \chkmk &         \\
275 \hline
276 \DWATmainsubprogram     & \chkmk  &        &           & \chkmk &         \\
277 \hline
278 \DWATname               & \chkmk  &        &           & \chkmk &         \\
279 \hline
280 \DWATproducer           & \chkmk  &        &           & \chkmk &         \\
281 \hline
282 \bbeb\DWATranges             & \chkmk  &        &  \chkmk   &        &         \\
283 \hline
284 \DWATrangesbase         & \chkmk  &        &  \chkmk   &        &         \\
285 \hline
286 \DWATstmtlist           & \chkmk  & \chkmk &  \chkmk   &        & \chkmk  \\
287 \hline
288 \DWATstroffsetsbase     & \chkmk  & \chkmk &  \chkmk   &        &         \\
289 \hline
290 \bbeb\DWATuseUTFeight        & \chkmk  & \chkmk &  \chkmk   & \chkmk & \chkmk  \\
291 \hline
292 \end{tabular}
293 \end{table}
294
295
296
297 \needlines{8}
298 The split dwarf object file design depends on having an index of 
299 debugging information available to the consumer. For name lookups, 
300 the consumer can use the \dotdebugnames{} index section (see 
301 Section \refersec{chap:acceleratedaccess}) to 
302 locate a skeleton compilation unit. The
303 \DWATcompdir{} and \DWATdwoname{} attributes in the skeleton
304 compilation unit can then be used to locate the corresponding
305 DWARF object file for the compilation unit. Similarly, for an
306 address lookup, the consumer can use the \dotdebugaranges{} table,
307 which will also lead to a skeleton compilation unit. For a file
308 and line number lookup, the skeleton compilation units can be
309 used to locate the line number tables.
310
311 \clearpage
312
313 \section{Split DWARF Object File Example}
314 \label{app:splitdwarfobjectfileexample}
315 \addtoindexx{split DWARF object file!example}
316 Consider the example source code in 
317 Figure \refersec{fig:splitobjectexamplesourcefragment1}, 
318 Figure \refersec{fig:splitobjectexamplesourcefragment2} and
319 Figure \refersec{fig:splitobjectexamplesourcefragment3}.
320 When compiled with split DWARF, we will have two DWARF object files,
321 \texttt{demo1.o} and \texttt{demo2.o}, and two \splitDWARFobjectfile{s}, 
322 \texttt{demo1.dwo} and \texttt{demo2.dwo}.
323
324 \vspace{2cm}
325 \begin{figure}[ht]
326 \textit{File demo1.cc}
327 \begin{lstlisting}
328 #include "demo.h"
329
330 bool Box::contains(const Point& p) const
331 {
332     return (p.x() >= ll_.x() && p.x() <= ur_.x() &&
333             p.y() >= ll_.y() && p.y() <= ur_.y());
334 }
335 \end{lstlisting}
336 \caption{Split object example: source fragment \#1}
337 \label{fig:splitobjectexamplesourcefragment1}
338 \end{figure}
339
340 \begin{figure}[ht]
341 \textit{File demo2.cc}
342 \begin{lstlisting}
343 #include "demo.h"
344
345 bool Line::clip(const Box& b)
346 {
347   float slope = (end_.y() - start_.y()) / (end_.x() - start_.x());
348   while (1) {
349     // Trivial acceptance.
350     if (b.contains(start_) && b.contains(end_)) return true;
351
352     // Trivial rejection.
353     if (start_.x() < b.l() && end_.x() < b.l()) return false;
354     if (start_.x() > b.r() && end_.x() > b.r()) return false;
355     if (start_.y() < b.b() && end_.y() < b.b()) return false;
356     if (start_.y() > b.t() && end_.y() > b.t()) return false;
357
358     if (b.contains(start_)) {
359       // Swap points so that start_ is outside the clipping 
360       // rectangle.
361       Point temp = start_;
362       start_ = end_;
363       end_ = temp;
364     }
365
366     if (start_.x() < b.l())
367       start_ = Point(b.l(), 
368                      start_.y() + (b.l() - start_.x()) * slope);
369     else if (start_.x() > b.r())
370       start_ = Point(b.r(), 
371                      start_.y() + (b.r() - start_.x()) * slope);
372     else if (start_.y() < b.b())
373       start_ = Point(start_.x() + (b.b() - start_.y()) / slope, 
374                      b.b());
375     else if (start_.y() > b.t())
376       start_ = Point(start_.x() + (b.t() - start_.y()) / slope, 
377                      b.t());
378   }
379 }
380 \end{lstlisting}
381 \caption{Split object example: source fragment \#2}
382 \label{fig:splitobjectexamplesourcefragment2}
383 \end{figure}
384
385 \begin{figure}[ht]
386 \textit{File demo.h}
387 \begin{lstlisting}
388 class A {
389   public:
390     Point(float x, float y) : x_(x), y_(y){}
391     float x() const { return x_; }
392     float y() const { return y_; }
393   private:
394     float x_;
395     float y_;
396 };
397
398 class Line {
399   public:
400     Line(Point start, Point end) : start_(start), end_(end){}
401     bool clip(const Box& b);
402     Point start() const { return start_; }
403     Point end() const { return end_; }
404   private:
405     Point start_;
406     Point end_;
407 };
408
409 class Box {
410   public:
411     Box(float l, float r, float b, float t) : ll_(l, b), ur_(r, t){}
412     Box(Point ll, Point ur) : ll_(ll), ur_(ur){}
413     bool contains(const Point& p) const;
414     float l() const { return ll_.x(); }
415     float r() const { return ur_.x(); }
416     float b() const { return ll_.y(); }
417     float t() const { return ur_.y(); }
418   private:
419     Point ll_;
420     Point ur_;
421 };
422
423 \end{lstlisting}
424 \caption{Split object example: source fragment \#3}
425 \label{fig:splitobjectexamplesourcefragment3}
426 \end{figure}
427
428 \clearpage
429 \subsection{Contents of the Object File}
430 The object files each contain the following sections of debug
431 information:
432 \begin{alltt}
433   \dotdebugabbrev
434   \dotdebuginfo
435   \dotdebugranges
436   \dotdebugline
437   \dotdebugstr
438   \dotdebugaddr
439   \dotdebugnames
440   \dotdebugaranges
441 \end{alltt}
442
443 The \dotdebugabbrev{} section contains just a single entry describing
444 the skeleton compilation unit DIE.
445
446 The DWARF description in the \dotdebuginfo{} section 
447 contains just a single DIE, the skeleton compilation unit, 
448 which may look like 
449 Figure \referfol{fig:splitdwafexampleskeletondwarfdescription}.
450
451 \begin{figure}[ht]
452 \begin{dwflisting}
453 \begin{alltt}
454
455     \DWTAGcompileunit
456         \DWATcompdir: (reference to directory name in .debug_str)
457         \DWATdwoname: (reference to "demo1.dwo" in .debug_str)
458         \DWATdwoid: 0x44e413b8a2d1b8f
459         \DWATaddrbase: (reference to .debug_addr section)
460         \DWATrangesbase: (reference to range list in .debug_ranges section)
461         \DWATranges: (offset of range list in .debug_ranges section)
462         \DWATstmtlist: (reference to .debug_line section)
463         \DWATlowpc: 0
464       
465 \end{alltt}
466 \end{dwflisting}
467 \caption{Split object example: Skeleton DWARF description}
468 \label{fig:splitdwafexampleskeletondwarfdescription}
469 \end{figure}
470
471 The \DWATcompdir{} and \DWATdwoname{} attributes provide the
472 location of the corresponding \splitDWARFobjectfile{} that
473 contains the full debug information; that file is normally
474 expected to be in the same directory as the object file itself.
475
476 The \DWATdwoid{} attribute provides a hash of the debug
477 information contained in the \splitDWARFobjectfile. This hash serves
478 two purposes: it can be used to verify that the debug information
479 in the \splitDWARFobjectfile{} matches the information in the object
480 file, and it can be used to find the debug information in a DWARF
481 package file.
482
483 \needlines{4}
484 The \DWATaddrbase{} attribute contains the relocatable offset of
485 this object file's contribution to the \dotdebugaddr{} section, and
486 the \DWATrangesbase{} attribute contains the relocatable offset
487 of this object file's contribution to the \dotdebugranges{} section.
488 The \DWATranges{} attribute refers to a specific range list within
489 that contribution, and its value is a (non-relocatable) offset
490 relative to the base. In a compilation unit with a single
491 contiguous range of code, the \DWATranges{} attribute might be
492 omitted, and instead replaced by the pair \DWATlowpc{} and
493 \DWAThighpc.
494
495 The \DWATstmtlist{} attribute contains the relocatable offset of
496 this file's contribution to the \dotdebugline{} table.
497
498 \bb
499 There is both a \DWATranges{} attribute as well as a \DWATlowpc{} 
500 attribute which
501 \eb
502 provides a default base address for the range list entries in the
503 \dotdebugranges{} section. 
504 \bbeb
505
506 The \dotdebugranges{} section contains the range list referenced by
507 the \DWATranges{} attribute in the skeleton compilation unit DIE,
508 plus any range lists referenced by \DWATranges{} attributes in the
509 split DWARF object. In 
510 \bb
511 this example, \texttt{demo1.o} contains range
512 \eb
513 list entries for the function \texttt{Box::contains}, as well as for
514 out-of-line copies of the inline functions \texttt{Point::x} and 
515 \texttt{Point::y}.
516
517 The \dotdebugline{} section contains the full line number table for
518 the compiled code in the object file. 
519 \bb
520 As shown in
521 Figure \refersec{fig:splitobjectexamplesourcefragment1}, the line
522 number program header lists the two file names, \texttt{demo.h} and
523 \texttt{demo1.cc}, and contains line number programs for
524 \eb
525 \texttt{Box::contains}, \texttt{Point::x}, and \texttt{Point::y}.
526
527 The \dotdebugstr{} section contains the strings referenced indirectly
528 by the compilation unit DIE and by the line number program.
529
530 The \dotdebugaddr{} section contains relocatable addresses of
531 locations in the loadable text and data that are referenced by
532 debugging information entries in the split DWARF object. In the
533 example in \refersec{fig:splitobjectexamplesourcefragment3}, 
534 \texttt{demo1.o} may have three entries:
535 \begin{center}
536 %\footnotesize
537 \begin{tabular}{cl}
538 Slot & Location referenced \\
539 \hline
540    0   &  low PC value for \texttt{Box::contains}  \\
541    1   &  low PC value for \texttt{Point::x}       \\
542    2   &  low PC value for \texttt{Point::y}       \\
543 \end{tabular}
544 \end{center}
545
546 \needlines{4}
547 The \dotdebugnames{}
548 section contains the names defined by the debugging
549 information in the \splitDWARFobjectfile{} 
550 (see Section \refersec{chap:contentsofthenameindex}), 
551 and references the skeleton compilation unit. 
552 When linked together into a final executable,
553 they can be used by a DWARF consumer to lookup a name to find one
554 or more skeleton compilation units that provide information about
555 that name. From the skeleton compilation unit, the consumer can
556 find the \splitDWARFobjectfile{} that it can then read to get the full
557 DWARF information.
558
559 The \dotdebugaranges{} section contains the PC ranges defined in this
560 compilation unit, and allow a DWARF consumer to map a PC value to
561 a skeleton compilation unit, and then to a \splitDWARFobjectfile.
562
563
564 \subsection{Contents of the Split DWARF Object Files}
565 The \splitDWARFobjectfile{s} each contain the following sections:
566 \begin{alltt}
567   \dotdebugabbrevdwo
568   \dotdebuginfodwo{} (for the compilation unit)
569   \dotdebuginfodwo{} (one COMDAT section for each type unit)
570   \dotdebuglocdwo
571   \dotdebuglinedwo
572   \dotdebugmacrodwo
573   \dotdebugstroffsetsdwo
574   \dotdebugstrdwo
575 \end{alltt}
576 The \dotdebugabbrevdwo{} section contains the abbreviation
577 declarations for the debugging information entries in the
578 \dotdebuginfodwo{} section. 
579 \bbeb
580
581 The \dotdebuginfodwo{} section containing the compilation unit
582 contains the full debugging information for the compile unit, and
583 looks much like a normal \dotdebuginfo{} section in a non-split
584 object file, with the following exceptions:
585 \begin{itemize}
586 \item The \DWTAGcompileunit{} DIE does not need to repeat the
587 \DWATranges, \DWATlowpc, \DWAThighpc, and
588 \DWATstmtlist{} attributes that are provided in the skeleton
589 compilation unit.
590
591 \item References to strings in the string table use the 
592 \bbeb
593 form code \DWFORMstrx, referring to slots in the
594 \dotdebugstroffsetsdwo{} section.
595
596 \bbpareb
597
598 \item References to range lists in the \dotdebugranges{} section are
599 all relative to the base offset given by \DWATrangesbase{}
600 in the skeleton compilation unit.
601
602 \needlines{4}
603 \item References to relocatable addresses in the object file use the 
604 \bbeb 
605 form code \DWFORMaddrx, referring to slots in the
606 \dotdebugaddr{} table, relative to the base offset given by
607 \DWATaddrbase{} in the skeleton compilation unit.
608 \end{itemize}
609
610 \vspace*{1mm}
611 Figure \referfol{fig:splitobjectexampledemoonedwodwarfexcerpts} presents
612 \bbeb
613 excerpts from the \dotdebuginfodwo{} section for \texttt{demo1.dwo}.
614
615 \begin{figure}[ht]
616 \vspace{1mm}
617 \figurepart{1}{2}
618 \begin{dwflisting}
619 \begin{alltt}
620
621     \DWTAGcompileunit
622         \DWATproducer [\DWFORMstrx]: (slot 15) (producer string)
623         \DWATlanguage: \DWLANGCplusplus
624         \DWATname [\DWFORMstrx]: (slot 7) "demo1.cc"
625         \DWATcompdir [\DWFORMstrx]: (slot 4) (directory name)
626         \DWATdwoid [\DWFORMdataeight]: 0x44e413b8a2d1b8f
627 1$:     \DWTAGclasstype
628             \DWATname [\DWFORMstrx]: (slot 12) "Point"
629             \DWATsignature [\DWFORMrefsigeight]: 0x2f33248f03ff18ab
630             \DWATdeclaration: true
631 2$:         \DWTAGsubprogram
632                 \DWATexternal: true
633                 \DWATname [\DWFORMstrx]: (slot 12) "Point"
634                 \DWATdeclfile: 1
635                 \DWATdeclline: 5
636                 \DWATlinkagename [\DWFORMstrx]: (slot 16): "_ZN5PointC4Eff"
637                 \DWATaccessibility: \DWACCESSpublic
638                 \DWATdeclaration: true
639             ...
640 3$:     \DWTAGclasstype
641             \DWATname [\DWFORMstring]: "Box"
642             \DWATsignature [\DWFORMrefsigeight{}]: 0xe97a3917c5a6529b
643             \DWATdeclaration: true
644           ...
645 4$:         \DWTAGsubprogram
646                 \DWATexternal: true
647                 \DWATname [\DWFORMstrx]: (slot 0) "contains"
648                 \DWATdeclfile: 1
649                 \DWATdeclline: 28
650                 \DWATlinkagename [\DWFORMstrx: (slot 8) "_ZNK3Box8containsERK5Point"
651                 \DWATtype: (reference to 7$)
652                 \DWATaccessibility: \DWACCESSpublic
653                 \DWATdeclaration: true
654           ...
655
656 \end{alltt}
657 \end{dwflisting}
658 \caption{Split object example: \texttt{demo1.dwo} excerpts}
659 \label{fig:splitobjectexampledemoonedwodwarfexcerpts}
660 \end{figure}
661         
662 \begin{figure}
663 \figurepart{2}{2}
664 \begin{dwflisting}
665 \begin{alltt}
666
667 5$:   \DWTAGsubprogram
668           \DWATspecification: (reference to 4$)
669           \DWATdeclfile: 2
670           \DWATdeclline: 3
671           \DWATlowpc [\DWFORMaddrx]: (slot 0)
672           \DWAThighpc [\DWFORMdataeight]: 0xbb
673           \DWATframebase: \DWOPcallframecfa
674           \DWATobjectpointer: (reference to 6$)
675 6$:       \DWTAGformalparameter
676               \DWATname [\DWFORMstrx]: (slot 13): "this"
677               \DWATtype: (reference to 8$)
678               \DWATartificial: true
679               \DWATlocation: \DWOPfbreg(-24)
680           \DWTAGformalparameter
681               \DWATname [\DWFORMstring]: "p"
682               \DWATdeclfile: 2
683               \DWATdeclline: 3
684               \DWATtype: (reference to 11$)
685               \DWATlocation: \DWOPfbreg(-32)
686       ...
687 7$:   \DWTAGbasetype
688           \DWATbytesize: 1
689           \DWATencoding: \DWATEboolean
690           \DWATname [\DWFORMstrx]: (slot 5) "bool"
691       ...
692 8$:   \DWTAGconsttype
693           \DWATtype: (reference to 9$)
694 9$:   \DWTAGpointertype
695           \DWATbytesize: 8
696           \DWATtype: (reference to 10$)
697 10$:  \DWTAGconsttype
698           \DWATtype: (reference to 3$)
699       ...
700 11$:  \DWTAGconsttype
701           \DWATtype: (reference to 12$)
702 12$:  \DWTAGreferencetype
703           \DWATbytesize: 8
704           \DWATtype: (reference to 13$)
705 13$:  \DWTAGconsttype
706           \DWATtype: (reference to 1$)
707       ...
708 \end{alltt}
709 \end{dwflisting}
710 \begin{center}
711 \vspace{3mm}
712 Figure~\ref{fig:splitobjectexampledemoonedwodwarfexcerpts}: Split object example: \texttt{demo1.dwo} DWARF excerpts \textit{(concluded)}
713 \end{center}
714 \end{figure}
715
716 \needlines{4}
717 In the defining declaration for \texttt{Box::contains} at 5\$, the
718 \DWATlowpc{} attribute is represented with \DWFORMaddrx,
719 referring to slot 0 in the \dotdebugaddr{} table from \texttt{demo1.o}.
720 That slot contains the relocated address of the beginning of the
721 function.
722
723 Each type unit is contained in its own COMDAT \dotdebuginfodwo{}
724 section, and looks like a normal type unit in a non-split object,
725 except that the \DWTAGtypeunit{} DIE contains a \DWATstmtlist{}
726 attribute that refers to a specialized \dotdebuglinedwo{}
727 \addtoindexx{type unit!specialized \texttt{.debug\_line.dwo} section in}
728 \addtoindexx{specialized \texttt{.debug\_line.dwo} section}
729 section. This
730 section contains a normal line number
731 program header with a list of include directories and filenames,
732 but no line number program. This section is used only as a
733 reference for filenames needed for \DWATdeclfile{} attributes
734 within the type unit.
735
736 The \dotdebugstroffsetsdwo{} section contains an entry for each
737 unique string in the string table. 
738 \bbeb
739 Each entry in the table is the offset of the string, which is
740 contained in the \dotdebugstrdwo{} section. 
741
742 In a split DWARF object file, all references to
743 strings go through this table (there are no
744 other offsets to \dotdebugstrdwo{} in a split
745 DWARF object file). That is, there
746 is no use of \DWFORMstrp{} in a split DWARF object file.
747
748 The offsets in these slots have no associated relocations, 
749 because they are not part of a relocatable object file.
750
751 \needlines{4}
752 When combined into a DWARF package file, however, each 
753 slot must be adjusted to refer to the appropriate offset 
754 within the merged string table (\dotdebugstrdwo{}).
755 The tool that builds the DWARF package file must understand 
756 the structure of the \dotdebugstroffsetsdwo{} section in 
757 order to apply the necessary adjustments. 
758 \bb
759 Section \refersec{app:dwarfpackagefileexample} presents
760 an example of a DWARF package file.
761 \eb
762
763 \needlines{4}
764 The \dotdebuglocdwo{} section contains the location lists referenced
765 by \DWATlocation{} attributes in the \dotdebuginfodwo{} section. This
766 section has a similar format to the \dotdebugloc{} section in a
767 non-split object, but it has some small differences as explained
768 in Section \refersec{datarep:locationlistentriesinsplitobjects}. 
769
770 \begin{figure}[b]
771 \figurepart{1}{2}
772 \begin{dwflisting}
773 \begin{alltt}
774
775 1$: \DWTAGclasstype
776         \DWATname [\DWFORMstrx]: (slot 20) "Line"
777         \DWATsignature [\DWFORMrefsigeight]: 0x79c7ef0eae7375d1
778         \DWATdeclaration: true
779         ...
780 2$:     \DWTAGsubprogram
781             \DWATexternal: true
782             \DWATname [\DWFORMstrx]: (slot 19) "clip"
783             \DWATdeclfile: 2
784             \DWATdeclline: 16
785             \DWATlinkagename [\DWFORMstrx]: (slot 2) "_ZN4Line4clipERK3Box"
786             \DWATtype: (reference to DIE for bool)
787             \DWATaccessibility: \DWACCESSpublic
788             \DWATdeclaration: true
789         ...
790
791 \end{alltt}
792 \end{dwflisting}
793 \caption{Split object example: \texttt{demo2.dwo} DWARF \dotdebuginfodwo{} excerpts}
794 \label{fig:splitobjectexampledemotwodwodwarfdebuginfodwoexcerpts}
795 \end{figure}
796
797 \begin{figure}[t]
798 \figurepart{2}{2}
799 \begin{dwflisting}
800 \begin{alltt}
801
802 3$:   \DWTAGsubprogram
803           \DWATspecification: (reference to 2$)
804           \DWATdeclfile: 1
805           \DWATdeclline: 3
806           \DWATlowpc [\DWFORMaddrx]: (slot 32)
807           \DWAThighpc [\DWFORMdataeight]: 0x1ec
808           \DWATframebase: \DWOPcallframecfa
809           \DWATobjectpointer: (reference to 4$)
810 4$:       \DWTAGformalparameter
811               \DWATname: (indexed string: 0x11): this
812               \DWATtype: (reference to DIE for type const Point* const)
813               \DWATartificial: 1
814               \DWATlocation: 0x0 (location list)
815 5$:       \DWTAGformalparameter
816               \DWATname: b
817               \DWATdeclfile: 1
818               \DWATdeclline: 3
819               \DWATtype: (reference to DIE for type const Box& const)
820               \DWATlocation [\DWFORMsecoffset]: 0x2a
821 6$:       \DWTAGlexicalblock
822               \DWATlowpc [\DWFORMaddrx]: (slot 17)
823               \DWAThighpc: 0x1d5
824 7$:           \DWTAGvariable
825                   \DWATname [\DWFORMstrx]: (slot 28): "slope"
826                   \DWATdeclfile: 1
827                   \DWATdeclline: 5
828                   \DWATtype: (reference to DIE for type float)
829                   \DWATlocation [\DWFORMsecoffset]: 0x49
830
831 \end{alltt}
832 \end{dwflisting}
833 \begin{center}
834 \vspace{3mm}
835 Figure~\ref{fig:splitobjectexampledemotwodwodwarfdebuginfodwoexcerpts}: Split object example: \texttt{demo2.dwo} DWARF \dotdebuginfodwo{} excerpts \textit{(concluded)}
836 \end{center}
837 \end{figure}
838
839
840 In \texttt{demo2.dwo} as shown in 
841 Figure \refersec{fig:splitobjectexampledemotwodwodwarfdebuginfodwoexcerpts}, 
842 the debugging information for \texttt{Line::clip} 
843 \bb
844 starting at \texttt{2\$}
845 \eb
846 describes a local 
847 variable \texttt{slope} 
848 \bb
849 at \texttt{7\$}
850 \eb
851 whose location varies based on the PC.
852 Figure \refersec{fig:splitobjectexampledemotwodwodwarfdebuglocdwoexcerpts} 
853 presents some excerpts from the \dotdebuginfodwo{} section for 
854 \texttt{demo2.dwo}.
855
856 \clearpage
857
858 In Figure \refersec{fig:splitobjectexampledemotwodwodwarfdebuginfodwoexcerpts},
859 the \DWTAGformalparameter{} entries at \texttt{4\$} and \texttt{5\$} refer to the
860 location lists at offset \texttt{0x0} and \texttt{0x2a}, respectively, and the
861 \DWTAGvariable{} entry for \texttt{slope} 
862 \bbeb
863 refers to the location list at offset \texttt{0x49}. 
864 Figure \refersec{fig:splitobjectexampledemotwodwodwarfdebuglocdwoexcerpts}
865 shows a representation of the
866 location lists at those offsets in the \dotdebuglocdwo{} section.
867
868 % Special commands for use in the folloing table
869 \newcommand{\XXLLEsl}{\hyperlink{chap:DWLLEstartlengthentry}{start\_length\_entry}
870                       \index{DW\_LLE\_start\_length\_entry}}
871 \newcommand{\XXLLEeol}{\hyperlink{chap:DWLLEendoflistentry}{end\_of\_list\_entry}
872                        \index{DW\_LLE\_end\_of\_list\_entry}}
873
874 \begin{figure}[ht]
875 \begin{dwflisting}
876 \begin{tabular}{rl|rr|rl}
877        &  entry type          & \multicolumn{2}{c}{range} 
878                                                & \multicolumn{2}{l}{\hspace{6mm}location} \\
879 offset & (DW\_LLE\_*)         & start & length & length & expression \\
880 \hline
881 &&&&& \\
882
883 0x00 & \XXLLEsl &  [9] & 0x002f & 0x0001 & \DWOPregfive~(rdi) \\
884 0x09 & \XXLLEsl & [11] & 0x01b9 & 0x0001 & \DWOPregthree~(rbx) \\
885 \bbeb 0x12 & \XXLLEsl & [29] & 0x0003 & 0x0003 & \DWOPbregtwelve~(r12): -8;\\
886 \bbeb      &          &      &        &        & \DWOPstackvalue \\
887 0x1d & \XXLLEsl & [31] & 0x0001 & 0x0003 & \DWOPentryvalue: \\
888      &          &      &        &        & (\DWOPregfive~(rdi)); \\
889      &          &      &        &        & \DWOPstackvalue \\
890 0x29 & \XXLLEeol &&&& \\
891 ------ &&&&& \\
892
893 0x2a & \XXLLEsl &  [9] & 0x002f & 0x0001 & \DWOPregfour~(rsi)) \\
894 0x33 & \XXLLEsl & [11] & 0x01ba & 0x0003 & \DWOPregsix~(rbp)) \\
895 0x3c & \XXLLEsl & [30] & 0x0003 & 0x0003 & \DWOPentryvalue: \\
896      &          &      &        &        & (\DWOPregfour~(rsi)); \\
897      &          &      &        &        & \DWOPstackvalue \\
898 0x48 & \XXLLEeol &&&& \\
899 ------ &&&&& \\
900
901 0x49 & \XXLLEsl & [10] & 0x0004 & 0x0001 & \DWOPregeighteen~(xmm1) \\
902 0x52 & \XXLLEsl & [11] & 0x01bd & 0x0002 & \DWOPfbreg: -36 \\
903 0x5c & \XXLLEeol &&&& \\
904 &&&& \\
905 \end{tabular}
906 \end{dwflisting}
907 \caption{Split object example: \texttt{demo2.dwo} DWARF \dotdebuglocdwo{} excerpts}
908 \label{fig:splitobjectexampledemotwodwodwarfdebuglocdwoexcerpts}
909 \end{figure}
910
911 In each \DWLLEstartlengthentry{}, the start field is the index
912 of a slot in the \dotdebugaddr{} section, relative to the base
913 offset defined by the compilations unit's \DWATaddrbase{}
914 attribute. The \dotdebugaddr{} slots referenced by these entries give
915 the relocated address of a label within the function where the
916 address range begins. 
917 \bb
918 The following length field gives the length of the
919 address range. The location, consisting of its own length and
920 a DWARF expression, is last.
921 \eb 
922
923 \clearpage
924 \section{DWARF Package File Example}
925 \label{app:dwarfpackagefileexample}
926 \addtoindexx{DWARF duplicate elimination!examples}
927
928
929 \bb
930 \addtoindex{DWARF package file} 
931 (see Section \refersec{datarep:dwarfpackagefiles})
932 \eb
933 is a collection of split DWARF object files.
934 In general, it will be much smaller than the sum of the split
935 DWARF object files, because the packaging process removes duplicate
936 type units and merges the string tables. Aside from those two
937 optimizations, however, each compilation unit and each type unit
938 from a split DWARF object file is copied verbatim into the package
939 file.
940
941 The package file contains the same set of sections as a split
942 DWARF object file, plus two additional sections described below.
943
944 The packaging utility, like a linker, combines sections of the
945 same name by concatenation. While a split DWARF object may
946 contain multiple \dotdebuginfodwo{} sections, one for the
947 compilation unit, and one for each type unit, a package file
948 contains a single \dotdebuginfodwo{} section. The combined
949 \dotdebuginfodwo{} section contains each compilation unit and one
950 copy of each type unit (discarding any duplicate type
951 signatures).
952
953 As part of merging the string tables, the packaging utility
954 treats the \dotdebugstrdwo{} and \dotdebugstroffsetsdwo{}
955 sections specially. Rather than
956 combining them by simple concatenation, it instead builds a new
957 string table consisting of the unique strings from each input
958 string table. Because all references to these strings use
959 \bb
960 form \DWFORMstrx{},
961 \eb
962 the packaging utility only needs to adjust the
963 string offsets in each \dotdebugstroffsetsdwo{} contribution after
964 building the new \dotdebugstrdwo{} section.
965
966 Each compilation unit or type unit consists of a set of
967 inter-related contributions to each section in the package file.
968 For example, a compilation unit may have contributions in
969 \dotdebuginfodwo{}, \dotdebugabbrevdwo{}, \dotdebuglinedwo{},
970 \dotdebugstroffsetsdwo{}, and so on. In order to maintain the ability 
971 for a consumer to follow references between these sections, the
972 package file contains two additional sections: a compilation unit
973 (CU) index, and a type unit (TU) index. These indexes allow a
974 consumer to look up a compilation unit (by its \CUsignature) or 
975 a type unit (by its \TUsignature), and locate each contribution 
976 that belongs to that unit.
977
978 For example, consider a package file, \texttt{demo.dwp}, formed by
979 combining \texttt{demo1.dwo} and \texttt{demo2.dwo} from the previous example
980 (see Appendix \refersec{app:splitdwarfobjectfileexample}). The
981 resulting package file would contain the sections shown in Figure
982 \refersec{fig:sectionsandcontributionsinapackagefile}, 
983 with contributions from each input file as shown.
984
985 \begin{figure}[ht]
986 \begin{center}
987 \begin{tabular}{P{4.7cm}|P{8cm}}
988 \hline
989 \bfseries \bbeb Section & \bfseries Source of section contributions \\
990 \hline
991   \dotdebugabbrevdwo{}
992 &    \dotdebugabbrevdwo{} from \texttt{demo1.dwo} \newline
993      \dotdebugabbrevdwo{} from \texttt{demo2.dwo} \\
994 \hline \newline
995   \dotdebuginfodwo{} \newline (for the compilation units and type units)
996 &    compilation unit from \texttt{demo1.dwo} \newline
997      compilation unit from \texttt{demo2.dwo} \newline
998      type unit for class \texttt{Box} from \texttt{demo1.dwo}   \newline
999      type unit for class \texttt{Point} from \texttt{demo1.dwo} \newline
1000      type unit for class \texttt{Line} from \texttt{demo2.dwo}  \\
1001 \hline
1002   \dotdebuglocdwo{}
1003 &    \dotdebuglocdwo{} from \texttt{demo1.dwo} \newline
1004      \dotdebuglocdwo{} from \texttt{demo2.dwo} \\
1005 \hline
1006   \dotdebuglinedwo{}
1007 &    \dotdebuglinedwo{} from \texttt{demo1.dwo} \newline
1008      \dotdebuglinedwo{} from \texttt{demo2.dwo} \\
1009 \hline
1010   \dotdebugstroffsetsdwo{}
1011 &    \dotdebugstroffsetsdwo{} from \texttt{demo1.dwo}, \hspace*{6mm}adjusted \newline
1012      \dotdebugstroffsetsdwo{} from \texttt{demo2.dwo}, \hspace*{6mm}adjusted \\
1013 \hline
1014   \dotdebugstrdwo{}
1015 &    \bbeb merged string table generated by package utility \\
1016 \hline
1017   \dotdebugcuindex
1018 &    \bbeb CU index generated by package utility \\
1019 \hline
1020   \dotdebugtuindex
1021 &    \bbeb TU index generated by package utility \\
1022 \hline
1023 \end{tabular}
1024 \end{center}
1025 \caption{Sections and contributions in example package file \texttt{demo.dwp}}
1026 \label{fig:sectionsandcontributionsinapackagefile}
1027 \end{figure}
1028
1029 \needlines{4}
1030 The \dotdebugabbrevdwo{}, \dotdebuglocdwo{} and \dotdebuglinedwo{}
1031 sections 
1032 \bb
1033 are
1034 \eb
1035 copied over from the two \texttt{.dwo} files as
1036 individual contributions to the corresponding sections in the
1037 \texttt{.dwp} file. 
1038 \bb
1039 The
1040 \eb
1041 offset of each contribution within 
1042 the combined section and the size of each contribution is recorded
1043 as part of the CU and TU index sections.
1044
1045 The \dotdebuginfodwo{} sections corresponding to each compilation unit 
1046 \bb
1047 are
1048 \eb
1049 copied as individual contributions to the combined
1050 \dotdebuginfodwo{} section, and one copy of each type unit 
1051 \bb
1052 is also
1053 \eb
1054 copied. The type units for class \texttt{Box} and class 
1055 \texttt{Point}, for example, are contained in both \texttt{demo1.dwo} 
1056 and \texttt{demo2.dwo}, but only one instance of each is copied into 
1057 the package file.
1058
1059 The \dotdebugstrdwo{} sections from each file 
1060 \bb
1061 are
1062 \eb
1063 merged to
1064 form a new string table with no duplicates, requiring the
1065 adjustment of all references to those strings. The
1066 \dotdebugstroffsetsdwo{} sections from the \texttt{.dwo} files 
1067 \bb
1068 are
1069 \eb
1070 copied as individual contributions, but the string table offset
1071 in each slot of those contributions 
1072 \bb
1073 is
1074 \eb
1075 adjusted to point to
1076 the correct offset in the merged string table.
1077
1078 \needlines{4}
1079 The \dotdebugcuindex{} and \dotdebugtuindex{} sections provide a
1080 directory to these contributions. 
1081 Figure \referfol{fig:examplecuindexsection} shows an example CU
1082 index section containing the two compilation units from 
1083 \texttt{demo1.dwo} and \texttt{demo2.dwo}. The CU index shows that 
1084 for the compilation unit from \texttt{demo1.dwo}, with \CUsignature{} 
1085 \texttt{0x044e413b8a2d1b8f}, its contribution to the \dotdebuginfodwo{} 
1086 section begins at offset 0, and is 325 bytes long. For the compilation 
1087 unit from \texttt{demo2.dwo}, with \CUsignature{} 
1088 \texttt{0xb5f0ecf455e7e97e}, its contribution to the \dotdebuginfodwo{}
1089 section begins at offset 325, and is 673 bytes long.
1090
1091 Likewise, we can find the contributions to the related sections.
1092 In Figure \refersec{fig:splitobjectexampledemotwodwodwarfdebuglocdwoexcerpts}, 
1093 we see that the \DWTAGvariable{} DIE at \texttt{7\$} has a
1094 reference to a location list at offset 0x49 (decimal 73). Because
1095 this is part of the compilation unit for \texttt{demo2.dwo}, with 
1096 unit signature \texttt{0xb5f0ecf455e7e97e}, we see that its contribution 
1097 to \dotdebuglocdwo{} begins at offset 84, so the location list from
1098 Figure \refersec{fig:splitobjectexampledemotwodwodwarfdebuglocdwoexcerpts} 
1099 can be found in \texttt{demo.dwp} at offset 157 (84 + 73) in
1100 the combined \dotdebuglocdwo{} section.
1101
1102 \begin{figure}[ht]
1103 \begin{center}
1104 \begin{tabular}{lrrrrrr}
1105 \\
1106   \multicolumn{7}{c}{Section header} \\
1107 \hline \\
1108   \multicolumn{2}{l}{Version:}&                 5 &&&&\\
1109   \multicolumn{2}{l}{Number of columns:}&       5 &&&&\\
1110   \multicolumn{2}{l}{Number of used entries:}&  2 &&&&\\
1111   \multicolumn{2}{l}{Number of slots:}&         16 &&&&\\
1112 \\
1113   \multicolumn{7}{c}{Offset table} \\
1114   \hline
1115   slot&  signature&             info&   abbrev&      loc&     line& str\_off \\
1116     14& \texttt{0xb5f0ecf455e7e97e}&      325&      452&       84&       52&       72 \\
1117     15& \texttt{0x044e413b8a2d1b8f}&        0&        0&        0&        0&        0 \\
1118 \\
1119   \multicolumn{7}{c}{Size table} \\
1120   \hline
1121   slot&                    &     info&   abbrev&      loc&     line& str\_off \\
1122     14&                    &      673&      593&       93&       52&      120 \\
1123     15&                    &      325&      452&       84&       52&       72 \\
1124 \\ \hline 
1125 \end{tabular}
1126 \end{center}
1127 \caption{Example CU index section}
1128 \label{fig:examplecuindexsection}
1129 \end{figure}
1130
1131 \needlines{4}
1132 Figure \referfol{fig:exampletuindexsection} 
1133 shows an example TU index section containing the
1134 three type units for classes \texttt{Box}, \texttt{Point}, and 
1135 \texttt{Line}. Each type unit
1136 contains contributions from \dotdebuginfodwo{}, \dotdebugabbrevdwo{},
1137 \dotdebuglinedwo{} and \dotdebugstroffsetsdwo{}. In this example, the
1138 type units for classes \texttt{Box} and \texttt{Point} come from 
1139 \texttt{demo1.dwo}, and
1140 share the abbreviations table, line number table, and string
1141 offsets table with the compilation unit from \texttt{demo1.dwo}. 
1142 Likewise, the type unit for class \texttt{Line} shares tables 
1143 from \texttt{demo2.dwo}. 
1144
1145 The sharing of these tables between compilation units and type units
1146 is typical for some implementations, but is not required by the
1147 DWARF standard.
1148
1149 \begin{figure}[ht]
1150 \begin{center}
1151 \begin{tabular}{lrrrrr}
1152 \\
1153   \multicolumn{6}{c}{Section header} \\
1154 \hline
1155   \multicolumn{2}{l}{Version:}&                 5 \\
1156   \multicolumn{2}{l}{Number of columns:}&       4 \\
1157   \multicolumn{2}{l}{Number of used entries:}&  3 \\
1158   \multicolumn{2}{l}{Number of slots:}&         32 \\
1159 \\
1160   \multicolumn{6}{c}{Offset table} \\
1161   \hline
1162   slot&  signature&                    info&   abbrev&     line& str\_off \\
1163   11& \texttt{0x2f33248f03ff18ab}&     1321&        0&        0&        0 \\
1164   17& \texttt{0x79c7ef0eae7375d1}&     1488&      452&       52&       72 \\
1165   27& \texttt{0xe97a3917c5a6529b}&      998&        0&        0&        0 \\
1166 \\
1167   \multicolumn{6}{c}{Size table} \\
1168   \hline
1169   slot&                          &     info&   abbrev&     line& str\_off \\
1170   11&                            &      167&      452&       52&       72 \\
1171   17&                            &      217&      593&       52&      120 \\
1172   27&                            &      323&      452&       52&       72 \\
1173 \\
1174 \hline
1175 \end{tabular}
1176 \end{center}
1177 \caption{Example TU index section}
1178 \label{fig:exampletuindexsection}
1179 \end{figure}
1180