More pagination cleanups using \needspace and \needlines.
[dwarf-doc.git] / dwarf5 / latexdoc / compression.tex
1 \chapter[Compression (Informative)]{DWARF Compression and Duplicate Elimination (Informative)}
2 \label{dwarfcompressionandduplicateeliminationinformative}
3
4 % It seemed difficult to get close to the same layout and 
5 % captioning as DWARF4 here with figures as they moved (floated)
6 % making it hard to follow.  Hence this uses fewer figures.
7
8 DWARF 
9 \addtoindexx{DWARF compression}
10 can 
11 \addtoindexx{DWARF duplicate elimination}
12 use a lot of disk space.
13
14 This is especially true for C++, where the depth and complexity
15 of headers can mean that many, many (possibly thousands of)
16 declarations are repeated in every compilation unit. C++
17 templates can also mean that some functions and their DWARF
18 descriptions get duplicated.
19
20 This Appendix describes techniques for using the DWARF
21 representation in combination with features and characteristics
22 of some common object file representations to reduce redundancy
23 without losing information. It is worth emphasizing that none
24 of these techniques are necessary to provide a complete and
25 accurate DWARF description; they are solely concerned with
26 reducing the size of DWARF information.
27
28 The techniques described here depend more directly and more
29 obviously on object file concepts and linker mechanisms than
30 most other parts of DWARF. While the presentation tends to
31 use the vocabulary of specific systems, this is primarily to
32 aid in describing the techniques by appealing to well\dash known
33 terminology. These techniques can be employed on any system
34 that supports certain general functional capabilities
35 (described below).
36
37
38 \section{Using Compilation Units}
39 \label{app:usingcompilationunits}
40
41 \subsection{Overview}
42 The general approach is to break up the debug information of
43 a compilation into separate normal and partial compilation
44 units, each consisting of one or more sections. By arranging
45 that a sufficiently similar partitioning occurs in other
46 compilations, a suitable system linker can delete redundant
47 groups of sections when combining object files.
48
49 \textit{The following uses some traditional section naming here
50 but aside from the DWARF sections, the names are just meant
51 to suggest traditional contents as a way of explaining the
52 approach, not to be limiting.}
53
54 A traditional relocatable object output 
55 from a single compilation might contain sections 
56 named:
57 \begin{alltt}
58     \addtoindex{.data}
59     \addtoindex{.text}
60     \addtoindex{.debug\_info}
61     \addtoindex{.debug\_abbrev}
62     \addtoindex{.debug\_line}
63     \addtoindex{.debug\_aranges}
64 \end{alltt}
65 A relocatable object from a compilation system 
66 attempting duplicate DWARF elimination might
67 contain sections as in:
68
69 \begin{alltt}
70     \addtoindex{.data}
71     \addtoindex{.text}
72     \addtoindex{.debug\_info}
73     \addtoindex{.debug\_abbrev}
74     \addtoindex{.debug\_line}
75     \addtoindex{.debug\_aranges}
76 \end{alltt}
77
78 followed (or preceded, the order is not significant) 
79 by a series of 
80 \addtoindexx{section group}
81 section groups:
82 \begin{alltt}
83 ==== Section group 1
84     \addtoindex{.debug\_info}
85     \addtoindex{.debug\_abbrev}
86     \addtoindex{.debug\_line}
87 ==== ...
88 ==== Section group N
89     \addtoindex{.debug\_info}
90     \addtoindex{.debug\_abbrev}
91     \addtoindex{.debug\_line}
92 \end{alltt}
93
94 where each \addtoindex{section group} might or might not contain executable
95 code (\textit{.text} sections) or data (\textit{.data} sections).
96
97 \needlines{6}
98 A \textit{\addtoindex{section group}} is a named set 
99 of section contributions
100 within an object file with the property that the entire set
101 of section contributions must be retained or discarded as a
102 whole; no partial elimination is allowed. Section groups can
103 generally be handled by a linker in two ways:
104
105 \begin{enumerate}[1.]
106 \item Given multiple identical (duplicate) section groups,
107 \addtoindexx{section group}
108 one of them is chosen to be kept and used, while the rest
109 are discarded.
110
111 \item Given a \addtoindex{section group} 
112 that is not referenced from any
113 section outside of the \addtoindex{section group}, 
114 the section group
115 is discarded.
116
117 \end{enumerate}
118
119
120 Which handling applies may be indicated by the 
121 \addtoindex{section group}
122 itself and/or selection of certain linker options.
123
124 For example, if a linker determines that 
125 \addtoindex{section group} 1
126 from A.o and 
127 \addtoindex{section group} 3 from B.o are identical, it could
128 discard one group and arrange that all references in A.o and
129 B.o apply to the remaining one of the two identical section
130 groups. This saves space.
131
132 An important part of making it possible to \doublequote{redirect}
133 references to the surviving 
134 \addtoindex{section group} is the use of
135 consistently chosen linker global symbols for referring to
136 locations within each 
137 \addtoindex{section group}.
138 It follows that references
139 are simply to external names and the linker already knows
140 how to match up references and definitions.
141
142 What is minimally needed from the object file format and system
143 linker (outside of DWARF itself, and normal object/linker
144 facilities such as simple relocations) are:
145
146 \begin{enumerate}[1.]
147
148 \item A means of referencing from inside one \addtoindex{.debug\_info}
149 compilation unit to another 
150 \addtoindex{.debug\_info} compilation unit
151 (\livelink{chap:DWFORMrefaddr}{DW\-\_FORM\-\_ref\-\_addr} provides this).
152
153 \item A means of having multiple contributions to specific sections
154 (for example, \addtoindex{.debug\_info}, and so on) in a single object file.
155
156 \item  A means of identifying a \addtoindex{section group} (giving it a name).
157
158 \item A means of identifying which sections go together to make
159 up a \addtoindex{section group}, 
160 so that the group can be treated as a unit
161 (kept or discarded).
162
163 \item  A means of indicating how each \addtoindex{section group} should be
164 processed by the linker.
165
166 \end{enumerate}
167
168 \textit{The notion of section and section contribution used here
169 corresponds closely to the similarly named concepts in the
170 ELF object file representation. 
171 The notion of \addtoindex{section group} is
172 an abstraction of common extensions of the ELF representation
173 widely known as ``COMDATs'' or ``COMDAT sections''. (Other
174 object file representations provide COMDAT\dash style mechanisms as
175 well.) There are several variations in the COMDAT schemes in
176 common use, any of which should be sufficient for the purposes
177 of the 
178 \addtoindexx{duplication elimination|see{DWARF duplicate elimination}}
179 DWARF duplicate elimination techniques described here.}
180
181 \subsection{Naming and Usage Considerations}
182 \label{app:namingandusageconsiderations}
183
184 A precise description of the means of deriving names usable
185 by the linker to access DWARF entities is not part of this
186 specification. Nonetheless, an outline of a usable approach
187 is given here to make this more understandable and to guide
188 implementors.
189
190 Implementations should clearly document their naming conventions.
191
192 In the following, it will be helpful to refer to the examples
193 in 
194 Figure \ref{fig:duplicateeliminationexample1csource}
195 through 
196 Figure \ref{fig:duplicateeliminationexample2companiondwarf}
197 of 
198 Section \refersec{app:examples}.
199
200 \textbf{Section Group Names}
201
202 Section groups must have a \addtoindex{section group} name.
203 \addtoindexx{section group!name}
204 For the subsequent 
205 \addtoindex{C++} example, a name like
206 \begin{alltt}
207     <producer-prefix>.<file-designator>.<gid-number>
208 \end{alltt}
209 will suffice, where
210
211 \begin{description}
212
213 \item  [\textless producer\dash prefix\textgreater] 
214 is some string specific to the
215 producer, which has a language\dash designation embedded in the
216 name when appropriate. (Alternatively, the language name
217 could be embedded in the 
218 \textless gid\dash number\textgreater).
219
220
221 \item  [\textless file\dash designator\textgreater]
222 names the file, such as wa.h in
223 the example.
224
225
226 \item  [\textless gid\dash number\textgreater]
227 is a string generated to identify the
228 specific wa.h header file in such a way that
229
230 \begin{itemize}
231
232 \item  a 'matching' output from another compile generates
233 the same 
234 \textless gid\dash number\textgreater,
235 and
236
237 \item  a non\dash matching output (say because of \#defines)
238 generates a different 
239 \textless gid\dash number\textgreater.
240 \end{itemize}
241
242 \end{description}
243
244 \textit{It may be useful to think of a 
245 \textless gid\dash number\textgreater
246 as a kind
247 of ``digital signature'' that allows a fast test for the
248 equality of two 
249 \addtoindexx{section group}
250 section groups.}
251
252 So, for example, the \addtoindex{section group} 
253 corresponding to file wa.h
254 above is given the name \textit{my.compiler.company.cpp.wa.h.123456}.
255
256
257
258 \textbf{Debugging Information Entry Names}
259
260 Global labels for 
261 \addtoindexx{debugging information entry!ownership relation}
262 debugging information entries (need explained
263 below) within a \addtoindex{section group}
264 can be given names of the form
265
266 \begin{alltt}
267     <prefix>.<file-designator>.<gid-number>.<die-number>
268 \end{alltt}
269
270 such as
271
272 \begin{alltt}
273     my.compiler.company.wa.h.123456.987
274 \end{alltt}
275
276 where
277 \begin{description}
278 \item [\textless prefix\textgreater]  
279 distinguishes this as a DWARF debug info name, and should identify the producer
280 and, when appropriate, the language.
281 \item [\textless file\dash designator\textgreater]  
282 and 
283 \texttt{\textless gid\dash number\textgreater} 
284 are as above.
285
286 \item  [\textless die\dash number\textgreater]
287 could be a number sequentially assigned 
288 to entities (tokens, perhaps) found
289 during compilation.
290
291 \end{description}
292
293 In general, every point in the 
294 \addtoindexx{section group}
295 section group 
296 \addtoindex{.debug\_info} that
297 could be referenced from outside by \emph{any} compilation unit must
298 normally have an external name generated for it in the linker
299 symbol table, whether the current compilation references all
300 those points or not.
301
302 \textit{The completeness of the set of names generated is a
303 quality\dash of\dash implementation issue.}
304
305 It is up to the producer to ensure that if 
306 \textless die\dash numbers\textgreater\ 
307 in separate compilations would not match properly then a
308 distinct 
309 \textless gid\dash number\textgreater\ 
310 is generated.
311
312 Note that only 
313 \addtoindexx{section group}
314 section groups that are designated as
315 duplicate\dash removal\dash applies actually require the
316 \begin{alltt}
317     <prefix>.<file-designator>.<gid-number>.<die-number>
318 \end{alltt}
319 external labels for debugging information entries as all other
320 \addtoindex{section group} sections can use 'local' labels 
321 (section\dash relative
322 relocations).
323
324 (This is a consequence of separate compilation, not a rule
325 imposed by this document.)
326
327 \textit{Local labels use references with form \livelink{chap:DWFORMref4}{DW\-\_FORM\-\_ref4}
328 or 
329 \livelink{chap:DWFORMref8}{DW\-\_FORM\-\_ref8}. 
330 (These are affected by relocations
331 so 
332 \livelink{chap:DWFORMrefudata}{DW\-\_FORM\-\_ref\-\_udata}, 
333 \livelink{chap:DWFORMref1}{DW\-\_FORM\-\_ref1} and 
334 \livelink{chap:DWFORMref2}{DW\-\_FORM\-\_ref2} are
335 normally not usable and 
336 \livelink{chap:DWFORMrefaddr}{DW\-\_FORM\-\_ref\-\_addr} is not necessary
337 for a local label.)}
338
339 % This should be a subsubsubsection header but that does work...
340 \textbf{Use of \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit} versus 
341 \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit}}
342
343 A \addtoindex{section group} compilation unit that uses 
344 \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}
345 is like any other compilation unit, in that its contents
346 are evaluated by consumers as though it were an ordinary
347 compilation unit.
348
349 An \#include directive appearing outside any other
350 declarations is a good candidate to be represented using
351 \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}. 
352 However, an \#include appearing inside
353 a \addtoindex{C++} namespace declaration or a function, for example, is
354 not a good candidate because the entities included are not
355 necessarily file level entities.
356
357 This also applies to \addtoindex{Fortran} INCLUDE lines when declarations
358 are included into a procedure or module context.
359
360 Consequently a compiler must use \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} (instead
361 of \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}) 
362 in a \addtoindex{section group} 
363 whenever the section group 
364 contents are not necessarily globally visible. 
365 This
366 directs consumers to ignore that compilation unit when scanning
367 top level declarations and definitions.
368
369 The \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} compilation unit will be referenced
370 from elsewhere and the referencing locations give the
371 appropriate context for interpreting the partial compilation
372 unit.
373
374 A \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} entry may have, as appropriate, any of
375 the attributes assigned to a \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}.
376
377
378 \textbf{Use of \livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit}}
379
380 A \livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit} debugging information entry has an
381 \livelink{chap:DWATimport}{DW\-\_AT\-\_import} attribute referencing a \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit} or
382 \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} debugging information entry.
383
384 A \livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit} debugging information entry refers
385 to a 
386 \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit} or 
387 \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} debugging
388 information entry to specify that the 
389 \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit} or
390 \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} contents logically appear at the point
391 of the 
392 \livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit} entry.
393
394
395 \textbf{Use of \livelink{chap:DWFORMrefaddr}{DW\-\_FORM\-\_ref\-\_addr}}
396
397 Use 
398 \livelink{chap:DWFORMrefaddr}{DW\-\_FORM\-\_ref\-\_addr} to reference from one compilation
399 unit's debugging information entries to those of another
400 compilation unit.
401
402 When referencing into a removable \addtoindex{section group}
403 \addtoindex{.debug\_info}
404 from another \addtoindex{.debug\_info} (from anywhere), the
405 \texttt{<prefix>.<file-designator>.<gid-number>.<die-number>}
406 name should be used for an external symbol and a relocation
407 generated based on that name.
408
409 \textit{When referencing into a 
410 \addtoindexx{section group}
411 non-section group 
412 \addtoindex{.debug\_info},
413 from another \addtoindex{.debug\_info} (from anywhere) 
414 \livelink{chap:DWFORMrefaddr}{DW\-\_FORM\-\_ref\-\_addr} is
415 still the form to be used, but a section\dash relative relocation
416 generated by use of a non-exported name (often called an
417 ``internal name'') may be used for references within the
418 same object file.}
419
420 \subsection{Examples}
421 \label{app:examples}
422
423 This section provides several 
424 \addtoindexx{DWARF duplicate elimination!examples}
425 examples in order to have a
426 concrete basis for discussion.
427
428 In these examples, the focus is on the arrangement of DWARF
429 information into sections (specifically the 
430 \addtoindex{.debug\_info}
431 section) and the naming conventions used to achieve references
432 into 
433 \addtoindexx{section group}
434 section groups. 
435 In practice, all of the examples that
436 follow involve DWARF sections other than just 
437 \addtoindex{.debug\_info}
438 (for example, \addtoindex{.debug\_line}, 
439 \addtoindex{.debug\_aranges}, or others);
440 however, only the \addtoindex{.debug\_info}
441 section is shown to keep the
442 examples compact and easier to read.
443
444 The grouping of sections into a named set is shown, but the means for achieving this in terms of
445 the underlying object language is not (and varies from system to system).
446
447 \subsubsection{C++ Example}
448
449 The \addtoindex{C++} source 
450 \addtoindexx{DWARF duplicate elimination!C++ example}
451 in 
452 Figure \refersec{fig:duplicateeliminationexample1csource}
453 is used to illustrate the DWARF
454 representation intended to allow duplicate elimination.
455
456 \begin{figure}[t]
457 \textit{File wa.h}
458 \begin{lstlisting}[numbers=none]
459 struct A {
460    int i;
461 };
462 \end{lstlisting}
463 \textit{File wa.c}
464 \begin{lstlisting}[numbers=none]
465 #include "wa.h";
466 int
467 f(A &a)
468 {
469     return a.i + 2;
470 }
471 \end{lstlisting}
472 \caption{Duplicate elimination example \#1: C++ Source}
473 \label{fig:duplicateeliminationexample1csource}
474 \end{figure}
475
476 Figure \refersec{fig:duplicateeliminationexample1dwarfsectiongroup}
477 shows the \addtoindex{section group} corresponding to the included file 
478 wa.h.
479
480 \begin{figure}
481 \begin{dwflisting}
482 % FIXME: the DWFORMrefn could use rethinking
483 \begin{alltt}
484 ==== Section group name:
485     my.compiler.company.cpp.wa.h.123456
486 == section \addtoindex{.debug\_info}
487 DW.cpp.wa.h.123456.1: ! linker global symbol
488     \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}
489         \livelink{chap:DWATlanguage}{DW\-\_AT\-\_language}(\livelink{chap:DWLANGCplusplus}{DW\-\_LANG\-\_C\-\_plus\-\_plus})
490         ...  ! other unit attributes
491 DW.cpp.wa.h.123456.2: ! linker global symbol
492     \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}
493         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("int")
494 DW.cpp.wa.h.123456.3: ! linker global symbol
495     \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type}
496         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("A")
497 DW.cpp.wa.h.123456.4: ! linker global symbol
498         \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
499         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("i")
500         \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(\livelink{chap:DWFORMrefn}{DW\-\_FORM\-\_refn} to DW.cpp.wa.h.123456.2)
501             ! (This is a local reference, so the more
502             ! compact form \livetarg{chap:DWFORMrefn}{DW\-\_FORM\-\_refn} 
503             ! for n 1,2,4, or 8 can be used)
504 \end{alltt}
505 \end{dwflisting}
506 \caption{Duplicate elimination example \#1: DWARF section group} 
507 \label{fig:duplicateeliminationexample1dwarfsectiongroup}
508 \end{figure}
509
510 Figure \refersec{fig:duplicateeliminationexample1primarycompilationunit}
511 shows the ``normal'' DWARF sections, which are not part of
512 any \addtoindex{section group}, 
513 and how they make use of the information
514 in the \addtoindex{section group} shown above.
515
516 \begin{figure}
517 \begin{dwflisting}
518 \begin{alltt}
519 == section .text
520     [generated code for function f]
521 == section \addtoindex{.debug\_info}
522     \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}
523 .L1:                   ! local (non-linker) symbol
524         \livelink{chap:DWTAGreferencetype}{DW\-\_TAG\-\_reference\-\_type}
525             \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to DW.cpp.wa.h.123456.3)
526         \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}
527             \livelink{chap:DWATname}{DW\-\_AT\-\_name}("f")
528             \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to DW.cpp.wa.h.123456.2)
529             \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable}
530                 \livelink{chap:DWATname}{DW\-\_AT\-\_name}("a")
531                 \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to .L1)
532         ...
533 \end{alltt}
534 \end{dwflisting}
535 \caption{Duplicate elimination example \#1: primary compilation unit} 
536 \label{fig:duplicateeliminationexample1primarycompilationunit}
537 \end{figure}
538
539 This example uses \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit} for the \addtoindex{section group},
540 implying that the contents of the compilation unit are
541 globally visible (in accordance with 
542 \addtoindex{C++} language rules).
543 \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} is not needed for the same reason.
544
545 \subsubsection{Fortran Example}
546
547
548 For a \addtoindex{Fortran}
549 \addtoindexx{DWARF duplicate elimination!Fortran example}
550 example, consider 
551 Figure \refersec{fig:duplicateeliminationexample2fortransource}.
552
553 \begin{figure}
554 \textit{File CommonStuff.fh}
555 \addtoindexx{Fortran}
556 \begin{lstlisting}[numbers=none]
557 IMPLICIT INTEGER(A-Z)
558 COMMON /Common1/ C(100)
559 PARAMETER(SEVEN = 7)
560 \end{lstlisting}
561
562 \textit{File Func.f}
563 \begin{lstlisting}[numbers=none]
564 FUNCTION FOO (N)
565 INCLUDE 'CommonStuff.fh'
566 FOO = C(N + SEVEN)
567 RETURN
568 END
569 \end{lstlisting}
570 \caption{Duplicate elimination example \#2: Fortran source} 
571 \label{fig:duplicateeliminationexample2fortransource}
572 \end{figure}
573
574
575 Figure \refersec{fig:duplicateeliminationexample2dwarfsectiongroup}
576 shows the \addtoindex{section group}
577 corresponding to the included file 
578 \addtoindexx{Fortran example}
579 CommonStuff.fh.
580
581 \begin{figure}
582 \begin{dwflisting}
583 \begin{alltt}
584 ==== Section group name:
585
586     my.f90.company.f90.CommonStuff.fh.654321
587
588 == section \addtoindex{.debug\_info}
589
590 DW.myf90.CommonStuff.fh.654321.1:    ! linker global symbol
591     \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit}
592         ! ...compilation unit attributes, including...
593         \livelink{chap:DWATlanguage}{DW\-\_AT\-\_language}(\livelink{chap:DWLANGFortran90}{DW\-\_LANG\-\_Fortran90})
594         \livelink{chap:DWATidentifiercase}{DW\-\_AT\-\_identifier\-\_case}(\livelink{chap:DWIDcaseinsensitive}{DW\-\_ID\-\_case\-\_insensitive})
595
596 DW.myf90.CommonStuff.fh.654321.2: ! linker global symbol
597 3\$: \livelink{chap:DWTAGarraytype}{DW\-\_TAG\-\_array\-\_type}
598         ! unnamed
599         \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to DW.f90.F90\$main.f.2)
600             ! base type INTEGER
601         \livelink{chap:DWTAGsubrangetype}{DW\-\_TAG\-\_subrange\-\_type}
602             \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to DW.f90.F90\$main.f.2)
603                 ! base type INTEGER)
604             \livelink{chap:DWATlowerbound}{DW\-\_AT\-\_lower\-\_bound}(constant 1)
605             \livelink{chap:DWATupperbound}{DW\-\_AT\-\_upper\-\_bound}(constant 100)
606
607 DW.myf90.CommonStuff.fh.654321.3: ! linker global symbol
608     \livelink{chap:DWTAGcommonblock}{DW\-\_TAG\-\_common\-\_block}
609         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("Common1")
610         \livelink{chap:DWATlocation}{DW\-\_AT\-\_location}(Address of common \nolink{block} Common1)
611         \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable}
612             \livelink{chap:DWATname}{DW\-\_AT\-\_name}("C")
613             \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to 3\$)
614             \livelink{chap:DWATlocation}{DW\-\_AT\-\_location}(address of C)
615
616 DW.myf90.CommonStuff.fh.654321.4: ! linker global symbol
617     \livelink{chap:DWTAGconstant}{DW\-\_TAG\-\_constant}
618         \livelink{chap:DWATname}{DW\-\_AT\-\_name}("SEVEN")
619         \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to DW.f90.F90\$main.f.2)
620             ! base type INTEGER
621         \livelink{chap:DWATconstvalue}{DW\-\_AT\-\_const\-\_value}(constant 7)
622 \end{alltt}
623 \end{dwflisting}
624 \caption{Duplicate elimination example \#2: DWARF section group}
625 \label{fig:duplicateeliminationexample2dwarfsectiongroup}
626 \end{figure}
627
628 Figure \refersec{fig:duplicateeliminationexample2primaryunit}
629 shows the sections for the primary compilation unit.
630
631 \begin{figure}
632 \begin{dwflisting}
633 \begin{alltt}
634 == section .text
635     [code for function Foo]
636
637 == section \addtoindex{.debug\_info}
638     \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}
639         \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}
640             \livelink{chap:DWATname}{DW\-\_AT\-\_name}("Foo")
641             \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to DW.f90.F90\$main.f.2)
642                 ! base type INTEGER
643             \livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit}
644                 \livelink{chap:DWATimport}{DW\-\_AT\-\_import}(reference to
645                     DW.myf90.CommonStuff.fh.654321.1)
646             \livelink{chap:DWTAGcommoninclusion}{DW\-\_TAG\-\_common\-\_inclusion} ! For Common1
647                 \livelink{chap:DWATcommonreference}{DW\-\_AT\-\_common\-\_reference}(reference to
648                     DW.myf90.CommonStuff.fh.654321.3)
649             \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable} ! For function result
650                 \livelink{chap:DWATname}{DW\-\_AT\-\_name}("Foo")
651                     \livelink{chap:DWATtype}{DW\-\_AT\-\_type}(reference to DW.f90.F90\$main.f.2)
652                         ! base type INTEGER
653 \end{alltt}
654 \end{dwflisting}
655 \caption{Duplicate elimination example \#2: primary unit}
656 \label{fig:duplicateeliminationexample2primaryunit}
657 \end{figure}
658
659 A companion main program is shown in 
660 Figure \refersec{fig:duplicateeliminationexample2companionsource}
661
662 \begin{figure}
663 \textit{File Main.f} 
664 \begin{lstlisting}[numbers=none]
665 INCLUDE 'CommonStuff.fh'
666 C(50) = 8
667 PRINT *, 'Result = ', FOO(50 - SEVEN)
668 END
669 \end{lstlisting}
670 \caption{Duplicate elimination example \#2: companion source }
671 \label{fig:duplicateeliminationexample2companionsource}
672 \end{figure}
673
674 \needlines{3}
675 That main program results in an object file that
676 contained a duplicate of the \addtoindex{section group} named
677 my.f90.company.f90.CommonStuff.fh.654321 
678 corresponding to the
679 included file as well as the remainder of the main subprogram
680 as shown in 
681 Figure \refersec{fig:duplicateeliminationexample2companiondwarf}.
682
683 \begin{figure}
684 \begin{dwflisting}
685 \begin{alltt}
686 == section \addtoindex{.debug\_info}
687     \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}
688         \livelink{chap:DWATname}{DW\-\_AT\-\_name}(F90\$main)
689         \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}
690             \livelink{chap:DWATname}{DW\-\_AT\-\_name}("INTEGER")
691             \livelink{chap:DWATencoding}{DW\-\_AT\-\_encoding}(\livelink{chap:DWATEsigned}{DW\-\_ATE\-\_signed})
692             \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size}(...)
693
694         \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}
695             ...
696         ...  ! other base types
697         \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}
698             \livelink{chap:DWATname}{DW\-\_AT\-\_name}("F90\$main")
699             \livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit}
700                 \livelink{chap:DWATimport}{DW\-\_AT\-\_import}(reference to
701                     DW.myf90.CommonStuff.fh.654321.1)
702             \livelink{chap:DWTAGcommoninclusion}{DW\-\_TAG\-\_common\-\_inclusion} ! for Common1
703                 \livelink{chap:DWATcommonreference}{DW\-\_AT\-\_common\-\_reference}(reference to
704                     DW.myf90.CommonStuff.fh.654321.3)
705             ...
706 \end{alltt}
707 \end{dwflisting}
708 \caption{Duplicate elimination example \#2: companion DWARF }
709 \label{fig:duplicateeliminationexample2companiondwarf}
710 \end{figure}
711
712 This example uses \livelink{chap:DWTAGpartialunit}{DW\-\_TAG\-\_partial\-\_unit} for the \addtoindex{section group}
713 because the included declarations are not independently
714 visible as global entities.
715
716
717 \needlines{6}
718 \subsubsection{C Example}
719
720 The \addtoindex{C} example 
721 \addtoindexx{DWARF duplicate elimination!C example}
722 in this Section might appear to be equally
723 valid as a \addtoindex{C} example. However, it is prudent to include
724 a \livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit}
725 in the primary unit 
726 (see Figure \refersec{fig:duplicateeliminationexample1primarycompilationunit})
727 with an \livelink{chap:DWATimport}{DW\-\_AT\-\_import} attribute that refers to the proper unit
728 in the \addtoindex{section group}.
729
730 \textit{The \addtoindex{C} rules for consistency of global (file scope) symbols
731 across compilations are less strict than for C++; inclusion
732 of the import unit attribute assures that the declarations of
733 the proper \addtoindex{section group} are considered before declarations
734 from other compilations.}
735
736
737 \section{Using Type Units}
738 \label{app:usingtypeunits}
739
740 A large portion of debug information is type information, and
741 in a typical compilation environment, many types are duplicated
742 many times. One method of controlling the amount of duplication
743 is separating each type into a separate 
744 \addtoindex{.debug\_types} section
745 and arranging for the linker to recognize and eliminate
746 duplicates at the individual type level.
747
748 Using this technique, each substantial type definition is
749 placed in its own individual section, while the remainder
750 of the DWARF information (non-type information, incomplete
751 type declarations, and definitions of trivial types) is
752 placed in the usual debug information section. In a typical
753 implementation, the relocatable object file may contain one
754 of each of these debug sections:
755
756 \begin{alltt}
757 \addtoindex{.debug\_abbrev}
758 \addtoindex{.debug\_info}
759 \addtoindex{.debug\_line}
760 \end{alltt}
761
762 and any number of these additional sections:
763
764 \begin{alltt}
765 \addtoindex{.debug\_types}
766 \end{alltt}
767
768 As discussed in the previous section 
769 (Section \refersec{app:usingcompilationunits}), 
770 many
771 linkers today support the concept of a COMDAT group or
772 linkonce section. The general idea is that a ``key'' can be
773 attached to a section or a group of sections, and the linker
774 will include only one copy of a \addtoindex{section group}
775 (or individual section) for any given key. 
776 For 
777 \addtoindex{.debug\_types} sections, the
778 key is the \addtoindex{type signature}
779 formed from the algorithm given in
780 Section \refersec{datarep:typesignaturecomputation}.
781
782 \subsection{Signature Computation Example}
783 \label{app:signaturecomputationexample}
784
785 As an example, 
786 \addtoindexx{type signature!example computation}
787 consider a \addtoindex{C++} header file 
788 containing the type definitions shown
789 in Figure \refersec{fig:typesignatureexamplescsource}.
790
791 \begin{figure}
792 \begin{lstlisting}
793 namespace N {
794
795     struct B;
796
797     struct C {
798         int x;
799         int y;
800     };
801
802     class A {
803     public:
804         A(int v);
805         int v();
806     private:
807         int v_;
808         struct A *next;
809         struct B *bp;
810         struct C c;
811     };
812 }
813 \end{lstlisting}
814 \caption{Type signature examples: C++ source}
815 \label{fig:typesignatureexamplescsource}
816 \end{figure}
817
818 Next, consider one possible representation of the DWARF
819 information that describes the type \doublequote{struct C} as shown
820 in 
821 \refersec{fig:typesignaturecomputation1dwarfrepresentation}:
822
823 \begin{figure}
824 \begin{dwflisting}
825 % We keep the : (colon) away from the attribute so tokenizing in the python tools
826 % does not result in adding : into the attribute name.
827 \begin{alltt}
828   \livelink{chap:DWTAGtypeunit}{DW\-\_TAG\-\_type\-\_unit}
829       \livelink{chap:DWATlanguage}{DW\-\_AT\-\_language} : \livelink{chap:DWLANGCplusplus}{DW\-\_LANG\-\_C\-\_plus\-\_plus} (4)
830     \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace}
831         \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "N"
832 L1:
833       \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type}
834           \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "C"
835           \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} : 8
836           \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
837           \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 5
838         \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
839             \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "x"
840             \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
841             \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 6
842             \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L2
843             \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} : 0
844         \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
845             \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "y"
846             \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
847             \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 7
848             \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L2
849             \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} : 4
850 L2:
851      \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}
852          \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} : 4
853          \livelink{chap:DWATencoding}{DW\-\_AT\-\_encoding} : \livelink{chap:DWATEsigned}{DW\-\_ATE\-\_signed}
854          \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "int"
855 \end{alltt}
856 \end{dwflisting}
857 \caption{Type signature computation \#1: DWARF representation}
858 \label{fig:typesignaturecomputation1dwarfrepresentation}
859 \end{figure}
860
861 \needlines{3}
862 In computing a signature for the type N::C, flatten the type
863 \addtoindexx{type signature}
864 description into a byte stream according to the procedure
865 outlined in 
866 Section \refersec{datarep:typesignaturecomputation}.
867 The result is shown in 
868 Figure \refersec{fig:typesignaturecomputation1flattenedbytestream}.
869
870 \begin{figure}
871 \begin{dwflisting}
872 \begin{alltt}
873 // Step 2: 'C' \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace} "N"
874 0x43 0x39 0x4e 0x00
875 // Step 3: 'D' \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type}
876 0x44 0x13
877 // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "C"
878 0x41 0x03 0x08 0x43 0x00
879 // Step 4: 'A' \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 8
880 0x41 0x0b 0x0d 0x08
881 // Step 7: First child ("x")
882     // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
883     0x44 0x0d
884     // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "x"
885     0x41 0x03 0x08 0x78 0x00
886     // Step 4: 'A' \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 0
887     0x41 0x38 0x0d 0x00
888     // Step 6: 'T' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#2)
889     0x54 0x49
890         // Step 3: 'D' \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}
891         0x44 0x24
892         // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "int"
893         0x41 0x03 0x08 0x69 0x6e 0x74 0x00
894         // Step 4: 'A' \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 4
895         0x41 0x0b 0x0d 0x04
896         // Step 4: 'A' \livelink{chap:DWATencoding}{DW\-\_AT\-\_encoding} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} \livelink{chap:DWATEsigned}{DW\-\_ATE\-\_signed}
897         0x41 0x3e 0x0d 0x05
898         // Step 7: End of \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type} "int"
899         0x00
900     // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "x"
901     0x00
902 // Step 7: Second child ("y")
903     // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
904     0x44 0x0d
905     // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "y"
906     0x41 0x03 0x08 0x78 0x00
907     // Step 4: 'A' \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 4
908     0x41 0x38 0x0d 0x04
909     // Step 6: 'R' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#2)
910     0x52 0x49 0x02
911     // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "y"
912     0x00
913 // Step 7: End of \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type} "C"
914 0x00
915 \end{alltt}
916 \end{dwflisting}
917 \caption{Type signature computation \#1: flattened byte stream}
918 \label{fig:typesignaturecomputation1flattenedbytestream}
919 \end{figure}
920
921 Running an \addtoindex{MD5 hash} over this byte stream, and taking the
922 low\dash order 64 bits, yields the final signature: 
923 0xd28081e8 dcf5070a.
924
925 Next, consider a representation of the DWARF information that
926 describes the type ``class A'' as shown in 
927 Figure \refersec{fig:typesignaturecomputation2dwarfrepresentation}.
928
929 \begin{figure}
930 \figurepart{1}{2}
931 \begin{dwflisting}
932 \begin{alltt}
933   \livelink{chap:DWTAGtypeunit}{DW\-\_TAG\-\_type\-\_unit}
934       \livelink{chap:DWATlanguage}{DW\-\_AT\-\_language} : \livelink{chap:DWLANGCplusplus}{DW\-\_LANG\-\_C\-\_plus\-\_plus} (4)
935     \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace}
936         \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "N"
937 L1:
938         \livelink{chap:DWTAGclasstype}{DW\-\_TAG\-\_class\-\_type}
939              \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "A"
940              \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} : 20
941              \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
942              \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 10
943            \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
944                 \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "v\_"
945                 \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
946                 \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 15
947                 \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L2
948                 \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} : 0
949                 \livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} : \livelink{chap:DWACCESSprivate}{DW\-\_ACCESS\-\_private}
950           \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
951                \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "next"
952                \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
953                \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 16
954                \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L3
955                \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} : 4
956                \livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} : \livelink{chap:DWACCESSprivate}{DW\-\_ACCESS\-\_private}
957           \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
958                \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "bp"
959                \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
960                \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 17
961                \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L4
962                \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} : 8
963                \livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} : \livelink{chap:DWACCESSprivate}{DW\-\_ACCESS\-\_private}
964           \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
965                \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "c"
966                \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
967                \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 18
968                \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : 0xd28081e8 dcf5070a (signature for struct C)
969                \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} : 12
970                \livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} : \livelink{chap:DWACCESSprivate}{DW\-\_ACCESS\-\_private}
971 \end{alltt}
972 \end{dwflisting}
973 \caption{Type signature computation \#2: DWARF representation}
974 \label{fig:typesignaturecomputation2dwarfrepresentation}
975 \end{figure}
976
977 \begin{figure}
978 \figurepart{2}{2}
979 \begin{dwflisting}
980 \begin{alltt}
981       \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}
982            \livelink{chap:DWATexternal}{DW\-\_AT\-\_external} : 1
983            \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "A"
984            \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
985            \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 12
986            \livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration} : 1
987         \livelink{chap:DWTAGformalparameter}{DW\-\_TAG\-\_formal\-\_parameter}
988            \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L3
989            \livelink{chap:DWATartificial}{DW\-\_AT\-\_artificial} : 1
990         \livelink{chap:DWTAGformalparameter}{DW\-\_TAG\-\_formal\-\_parameter}
991            \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L2
992        \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}
993            \livelink{chap:DWATexternal}{DW\-\_AT\-\_external} : 1
994            \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "v"
995            \livelink{chap:DWATdeclfile}{DW\-\_AT\-\_decl\-\_file} : 1
996            \livelink{chap:DWATdeclline}{DW\-\_AT\-\_decl\-\_line} : 13
997            \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L2
998            \livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration} : 1
999          \livelink{chap:DWTAGformalparameter}{DW\-\_TAG\-\_formal\-\_parameter}
1000            \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L3
1001            \livelink{chap:DWATartificial}{DW\-\_AT\-\_artificial} : 1
1002 L2:
1003     \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}
1004          \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} : 4
1005          \livelink{chap:DWATencoding}{DW\-\_AT\-\_encoding} : \livelink{chap:DWATEsigned}{DW\-\_ATE\-\_signed}
1006          \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "int"
1007 L3:
1008     \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type}
1009          \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L1
1010 L4:
1011     \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type}
1012          \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : reference to L5
1013     \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace}
1014          \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "N"
1015 L5:
1016        \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type}
1017            \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "B"
1018            \livelink{chap:DWATdeclaration}{DW\-\_AT\-\_declaration} : 1
1019 \end{alltt}
1020 \end{dwflisting}
1021 \begin{center}
1022 Figure~\ref{fig:typesignaturecomputation2dwarfrepresentation} Type signature computation \#2: DWARF representation \textit{(concluded)}
1023 \end{center}
1024 \end{figure}
1025
1026 In this example, the structure types N::A and N::C have each
1027 been placed in separate 
1028 \addtoindexx{type unit}
1029 type units.  For N::A, the actual
1030 definition of the type begins at label L1. The definition
1031 involves references to the int base type and to two pointer
1032 types. The information for each of these referenced types is
1033 also included in this \addtoindex{type unit}, 
1034 since base types and pointer
1035 types are trivial types that are not worth the overhead of a
1036 separate \addtoindex{type unit}. 
1037 The last pointer type contains a reference
1038 to an incomplete type N::B, which is also included here as
1039 a declaration, since the complete type is unknown and its
1040 signature is therefore unavailable. There is also a reference
1041 to N::C, using 
1042 \livelink{chap:DWFORMrefsig8}{DW\-\_FORM\-\_ref\-\_sig8} to 
1043 refer to the type signature
1044 \addtoindexx{type signature}
1045 for that type.
1046
1047 In computing a signature for the type N::A, flatten the type
1048 description into a byte stream according to the procedure
1049 outlined in 
1050 Section \refersec{datarep:typesignaturecomputation}.
1051 The result is shown in 
1052 Figure \refersec{fig:typesignatureexample2flattenedbytestream}.
1053
1054 \begin{figure}
1055 \figurepart{1}{3}
1056 \begin{dwflisting}
1057 % DWARF4 had a \livelink{chap:DWATnamespace}{DW_AT_namespace} below, 
1058 % but this error is fixed here to be \livelink{chap:DWTAGnamespace}{DW_TAG_namespace}.
1059 \begin{alltt}
1060 // Step 2: 'C' \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace} "N"
1061 0x43 0x39 0x4e 0x00
1062 // Step 3: 'D' \livelink{chap:DWTAGclasstype}{DW\-\_TAG\-\_class\-\_type}
1063 0x44 0x02
1064 // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "A"
1065 0x41 0x03 0x08 0x41 0x00
1066 // Step 4: 'A' \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 20
1067 0x41 0x0b 0x0d 0x14
1068 // Step 7: First child ("v\_")
1069     // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
1070     0x44 0x0d
1071     // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "v\_"
1072     0x41 0x03 0x08 0x76 0x5f 0x00
1073     // Step 4: 'A' \livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} \livelink{chap:DWACCESSprivate}{DW\-\_ACCESS\-\_private}
1074     0x41 0x32 0x0d 0x03
1075     // Step 4: 'A' \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 0
1076     0x41 0x38 0x0d 0x00
1077     // Step 6: 'T' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#2)
1078     0x54 0x49
1079         // Step 3: 'D' \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type}
1080         0x44 0x24
1081         // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "int"
1082         0x41 0x03 0x08 0x69 0x6e 0x74 0x00
1083         // Step 4: 'A' \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 4
1084         0x41 0x0b 0x0d 0x04
1085         // Step 4: 'A' \livelink{chap:DWATencoding}{DW\-\_AT\-\_encoding} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} \livelink{chap:DWATEsigned}{DW\-\_ATE\-\_signed}
1086         0x41 0x3e 0x0d 0x05
1087         // Step 7: End of \livelink{chap:DWTAGbasetype}{DW\-\_TAG\-\_base\-\_type} "int"
1088         0x00
1089     // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "v\_"
1090     0x00
1091 // Step 7: Second child ("next")
1092     // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
1093     0x44 0x0d
1094     // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "next"
1095     0x41 0x03 0x08 0x6e 0x65 0x78 0x74 0x00
1096     // Step 4: 'A' \livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} \livelink{chap:DWACCESSprivate}{DW\-\_ACCESS\-\_private}
1097     0x41 0x32 0x0d 0x03
1098     // Step 4: 'A' \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 4
1099     0x41 0x38 0x0d 0x04
1100 \end{alltt}
1101 \end{dwflisting}
1102 \caption{Type signature example \#2: flattened byte stream}
1103 \label{fig:typesignatureexample2flattenedbytestream}
1104 \end{figure}
1105
1106 \begin{figure}
1107 \figurepart{2}{3}
1108 \begin{dwflisting}
1109 \begin{alltt}    
1110     // Step 6: 'T' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#3)
1111     0x54 0x49
1112         // Step 3: 'D' \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type}
1113         0x44 0x0f
1114         // Step 5: 'N' \livelink{chap:DWATtype}{DW\-\_AT\-\_type}
1115         0x4e 0x49
1116         // Step 5: 'C' \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace} "N" 'E'
1117         0x43 0x39 0x4e 0x00 0x45
1118         // Step 5: "A"
1119         0x41 0x00
1120         // Step 7: End of \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type}
1121         0x00
1122     // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "next"
1123     0x00
1124 // Step 7: Third child ("bp")
1125     // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
1126     0x44 0x0d
1127     // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "bp"
1128     0x41 0x03 0x08 0x62 0x70 0x00
1129     // Step 4: 'A' \livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} \livelink{chap:DWACCESSprivate}{DW\-\_ACCESS\-\_private}
1130     0x41 0x32 0x0d 0x03
1131     // Step 4: 'A' \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 8
1132     0x41 0x38 0x0d 0x08
1133     // Step 6: 'T' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#4)
1134     0x54 0x49
1135         // Step 3: 'D' \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type}
1136 0x44 0x0f
1137         // Step 5: 'N' \livelink{chap:DWATtype}{DW\-\_AT\-\_type}
1138         0x4e 0x49
1139         // Step 5: 'C' \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace} "N" 'E'
1140         0x43 0x39 0x4e 0x00 0x45
1141         // Step 5: "B"
1142         0x42 0x00
1143         // Step 7: End of \livelink{chap:DWTAGpointertype}{DW\-\_TAG\-\_pointer\-\_type}
1144         0x00
1145     // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "next"
1146     0x00
1147 // Step 7: Fourth child ("c")
1148     // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
1149     0x44 0x0d
1150     // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "c"
1151     0x41 0x03 0x08 0x63 0x00
1152     // Step 4: 'A' \livelink{chap:DWATaccessibility}{DW\-\_AT\-\_accessibility} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} \livelink{chap:DWACCESSprivate}{DW\-\_ACCESS\-\_private}
1153     0x41 0x32 0x0d 0x03
1154 \end{alltt}
1155 \end{dwflisting}
1156 \begin{center}
1157 Figure~\ref{fig:typesignatureexample2flattenedbytestream} Type signature example \#2: flattened byte stream \textit{(continued)}
1158 \end{center}
1159 \end{figure}
1160     
1161 \begin{figure}
1162 \figurepart{3}{3}
1163 \begin{dwflisting}
1164 \begin{alltt}
1165     // Step 4: 'A' \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 12
1166     0x41 0x38 0x0d 0x0c
1167     // Step 6: 'T' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#5)
1168     0x54 0x49
1169         // Step 2: 'C' \livelink{chap:DWTAGnamespace}{DW\-\_TAG\-\_namespace} "N"
1170         0x43 0x39 0x4e 0x00
1171         // Step 3: 'D' \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type}
1172         0x44 0x13
1173         // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "C"
1174         0x41 0x03 0x08 0x43 0x00
1175         // Step 4: 'A' \livelink{chap:DWATbytesize}{DW\-\_AT\-\_byte\-\_size} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 8
1176         0x41 0x0b 0x0d 0x08
1177         // Step 7: First child ("x")
1178             // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
1179             0x44 0x0d
1180             // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "x"
1181             0x41 0x03 0x08 0x78 0x00
1182             // Step 4: 'A' \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 0
1183             0x41 0x38 0x0d 0x00
1184             // Step 6: 'R' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#2)
1185             0x52 0x49 0x02
1186             // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "x"
1187             0x00
1188         // Step 7: Second child ("y")
1189             // Step 3: 'D' \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member}
1190             0x44 0x0d
1191             // Step 4: 'A' \livelink{chap:DWATname}{DW\-\_AT\-\_name} \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} "y"
1192             0x41 0x03 0x08 0x79 0x00
1193             // Step 4: 'A' \livelink{chap:DWATdatamemberlocation}{DW\-\_AT\-\_data\-\_member\-\_location} \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} 4
1194             0x41 0x38 0x0d 0x04
1195             // Step 6: 'R' \livelink{chap:DWATtype}{DW\-\_AT\-\_type} (type \#2)
1196             0x52 0x49 0x02
1197             // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "y"
1198             0x00
1199         // Step 7: End of \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type} "C"
1200         0x00
1201     // Step 7: End of \livelink{chap:DWTAGmember}{DW\-\_TAG\-\_member} "c"
1202     0x00
1203 // Step 7: Fifth child ("A")
1204     // Step 3: 'S' \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram} "A"
1205     0x53 0x2e 0x41 0x00
1206 // Step 7: Sixth child ("v")
1207     // Step 3: 'S' \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram} "v"
1208     0x53 0x2e 0x76 0x00
1209 // Step 7: End of \livelink{chap:DWTAGstructuretype}{DW\-\_TAG\-\_structure\-\_type} "A"
1210 0x00
1211 \end{alltt}
1212 \end{dwflisting}
1213 \begin{center}
1214 Figure~\ref{fig:typesignatureexample2flattenedbytestream} Type signature example \#2: flattened byte stream \textit{(concluded)}
1215 \end{center}
1216 \end{figure}
1217
1218 Running an \addtoindex{MD5 hash} over this byte stream, and taking the
1219 low-order 64 bits, yields the final signature: 0xd6d160f5
1220 5589f6e9.
1221
1222
1223 A source file that includes this header file may declare a
1224 variable of type N::A, and its DWARF information may look
1225 like that shown in 
1226 Figure \refersec{fig:typesignatureexampleusage}.
1227
1228 \begin{figure}
1229 \begin{dwflisting}
1230 \begin{alltt}
1231   \livelink{chap:DWTAGcompileunit}{DW\-\_TAG\-\_compile\-\_unit}
1232   ...
1233   \livelink{chap:DWTAGsubprogram}{DW\-\_TAG\-\_subprogram}
1234     ...
1235     \livelink{chap:DWTAGvariable}{DW\-\_TAG\-\_variable}
1236       \livelink{chap:DWATname}{DW\-\_AT\-\_name} : "a"
1237       \livelink{chap:DWATtype}{DW\-\_AT\-\_type} : (signature) 0xd6d160f5 5589f6e9
1238       \livelink{chap:DWATlocation}{DW\-\_AT\-\_location} : ...
1239     ...
1240 \end{alltt}
1241 \end{dwflisting}
1242 \caption{Type signature example usage}
1243 \label{fig:typesignatureexampleusage}
1244 \end{figure}
1245
1246 \subsection{Type Signature Computation Grammar}
1247 \label{app:typesignaturecomputationgrammar}
1248
1249 Figure \refersec{fig:typesignaturecomputationgrammar}
1250 \addtoindexx{type signature!computation grammar}
1251 presents a semi-formal grammar that may aid in understanding
1252 how the bytes of the flattened type description are formed
1253 during the type signature computation algorithm of
1254 Section \refersec{datarep:typesignaturecomputation}. 
1255
1256 \begin{figure}[h]
1257 \begin{dwflisting}
1258 %FIXME: The index entries here with \addtoindexx are ineffective.
1259 \begin{alltt}
1260 signature
1261     : opt-context debug-entry attributes children
1262 opt-context           // Step 2
1263     : 'C' tag-code string opt-context
1264     : empty
1265 debug-entry           // Step 3
1266     : 'D' tag-code
1267 attributes            // Steps 4, 5, 6
1268     : attribute attributes
1269     : empty
1270 attribute
1271     : 'A' at-code form-encoded-value     // Normal attributes
1272     : 'N' at-code opt-context 'E' string // Reference to type by name
1273     : 'R' at-code back-ref               // Back-reference to visited type
1274     : 'T' at-code signature              // Recursive type
1275 children             //  Step 7
1276     : child children
1277     : '0'
1278 child
1279     : 'S' tag-code string
1280     : signature
1281 tag-code
1282     : <ULEB128>
1283 at-code
1284     : <ULEB128>
1285 form-encoded-value
1286     : \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} value \addtoindexx{constant class}
1287     : \livelink{chap:DWFORMflag}{DW\-\_FORM\-\_flag} value \addtoindexx{flag class}
1288     : \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} string \addtoindexx{string class}
1289     : \livelink{chap:DWFORMblock}{DW\-\_FORM\-\_block} \nolink{block} \addtoindexx{block class}
1290 \livelink{chap:DWFORMstring}{DW\-\_FORM\-\_string} \addtoindexx{string class}
1291     : 'x08'
1292 \livelink{chap:DWFORMblock}{DW\-\_FORM\-\_block}  \addtoindexx{block class}
1293     : 'x09'
1294 \livelink{chap:DWFORMflag}{DW\-\_FORM\-\_flag} \addtoindexx{flag class}
1295     : 'x0c'
1296 \livelink{chap:DWFORMsdata}{DW\-\_FORM\-\_sdata} \addtoindexx{constant class}
1297     : 'x0d'
1298 value
1299     : <SLEB128>
1300 \nolink{block}
1301     : <ULEB128> <fixed-length-block> // The ULEB128 gives the length of the \nolink{block}
1302 back-ref
1303     : <ULEB128>
1304 string
1305     : <null-terminated-string>
1306 empty
1307     :
1308 \end{alltt}
1309 \end{dwflisting}
1310 \caption{Type signature computation grammar}
1311 \label{fig:typesignaturecomputationgrammar}
1312 \end{figure}
1313
1314 \section{Summary of Compression Techniques}
1315 \label{app:summaryofcompressiontechniques}
1316 \subsection{\#include compression}
1317 \label{app:includecompression}
1318
1319 \addtoindex{C++} has a much greater 
1320 problem than 
1321 \addtoindex{C} with the number and
1322 size of the headers included and the amount of data in each,
1323 but even with \addtoindex{C} 
1324 there is substantial header file information
1325 duplication.
1326
1327 A reasonable approach is to put each header file in its own
1328 \addtoindex{section group}, using the naming rules mentioned above. The
1329 section groups are marked to ensure duplicate removal.
1330
1331 All data instances and code instances (even if they came
1332 from the header files above) are put 
1333 \addtoindexx{section group}
1334 into non-section group
1335 sections such as the base object file 
1336 \addtoindex{.debug\_info} section.
1337
1338 \subsection{Eliminating function duplication}
1339 \label{app:eliminatingfunctionduplication}
1340
1341
1342 Function templates (C++) result in code for the same template
1343 instantiation being compiled into multiple archives or
1344 relocatable objects. The linker wants to keep only one of a
1345 given entity. The DWARF description, and everything else for
1346 this function, should be reduced to just a single copy.
1347
1348 For each such code group (function template in this example)
1349 the compiler assigns a name for the group which will match
1350 all other instantiations of this function but match nothing
1351 else. 
1352 The 
1353 \addtoindexx{section group}
1354 section groups are marked to ensure duplicate
1355 removal, so that the second and subsequent definitions seen
1356 by the static linker are simply discarded.
1357
1358
1359 References to other 
1360 \addtoindex{.debug\_info} sections follow the approach
1361 suggested above, but the naming rule is slightly
1362 different in that the \texttt{\textless file-designator\textgreater} 
1363 should be interpreted as a \texttt{\textless file-designator\textgreater}.
1364
1365
1366
1367 \subsection{Single-function-per-DWARF-compilation-unit}
1368 \label{app:singlefunctionperdwarfcompilationunit}
1369
1370 Section groups can help make it easy for a linker to completely
1371 remove unused functions.
1372
1373 Such 
1374 \addtoindexx{section group}
1375 section groups are not marked for duplicate removal,
1376 since the functions are not duplicates of anything.
1377
1378 Each function is given a compilation unit and a section
1379 group. Each such compilation unit is complete, with its own
1380 text, data, and DWARF sections.
1381
1382 There will also be a compilation unit that has the file\dash level
1383 declarations and definitions. Other per\dash function compilation
1384 unit DWARF information (
1385 \addtoindex{.debug\_info}) points to this common
1386 file\dash level compilation unit using \livelink{chap:DWTAGimportedunit}{DW\-\_TAG\-\_imported\-\_unit}.
1387
1388 Section groups can use \livelink{chap:DWFORMrefaddr}{DW\-\_FORM\-\_ref\-\_addr} and internal labels
1389 (section\dash relative relocations) to refer to the main object
1390 file sections, as the 
1391 \addtoindexx{section group}
1392 section groups here are either deleted
1393 as unused or kept. There is no possibility (aside from error)
1394 of a group from some other compilation being used in place
1395 of one of these groups.
1396
1397
1398 \subsection{Inlining and out-of-line-instances}
1399 \label{app:inliningandoutoflineinstances}
1400
1401 Abstract instances
1402 \addtoindexx{abstract instance}
1403 \addtoindexx{concrete out-of-line instance}
1404 and concrete-out-of-line instances may be
1405 put in distinct compilation units using 
1406 \addtoindexx{section group}
1407 section groups. 
1408 This
1409 makes possible some useful duplicate DWARF elimination.
1410
1411 \textit{No special provision for eliminating class duplication
1412 resulting from template instantiation is made here, though
1413 nothing prevents eliminating such duplicates using section
1414 groups.}
1415
1416
1417 \subsection{Separate Type Units}
1418 \label{app:separatetypeunits}
1419
1420 Each complete declaration of a globally-visible type can be
1421 \addtoindexx{type unit}
1422 placed in its own separate type section, with a group key
1423 derived from the type signature. The linker can then remove
1424 all duplicate type declarations based on the key.
1425