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