90cd1766b26be361398e3bd4ab4cab6ca0e3d875
[dwarf-doc.git] / dwarf5 / latexdoc / examples.tex
1 \chapter{Examples (Informative)}
2 \label{app:examplesinformative}
3
4 The following sections provide examples that illustrate
5 various aspects of the DWARF debugging information format.
6
7
8
9 \section{ Compilation Units and Abbreviations Table Example}
10 \label{app:compilationunitsandabbreviationstableexample}
11
12
13 Figure 48  FIXME REF
14 depicts the relationship of the abbreviations tables contained
15 in the .debug\_abbrev section to the information contained in
16 the .debug\_info section. Values are given in symbolic form,
17 where possible.
18
19 The figure corresponds to the following two trivial source files:
20
21 File myfile.c
22 \begin{lstlisting}
23 typedef char* POINTER;
24 \end{lstlisting}
25 File myfile2.c
26 \begin{lstlisting}
27 typedef char* strp;
28 \end{lstlisting}
29
30
31 Needs content FIXME
32
33 \section{Aggregate Examples}
34 \label{app:aggregateexamples}
35
36 The following examples illustrate how to represent some of
37 the more complicated forms of array and record aggregates
38 using DWARF.
39
40 \subsection{Fortran 90 Example}
41 \label{app:fortran90example}
42 Consider the Fortran 90 source fragment in 
43 Figure \refersec{fig:fortran90examplesourcefragment}.
44
45 \begin{figure}[here]
46 \begin{lstlisting}
47 type array_ptr
48 real :: myvar
49 real, dimension (:), pointer :: ap
50 end type array_ptr
51 type(array_ptr), allocatable, dimension(:) :: arrays
52 allocate(arrays(20))
53 do i = 1, 20
54 allocate(arrays(i)%ap(i+10))
55 end do
56 \end{lstlisting}
57 \caption{Fortran 90 example: source fragment} \label{fig:fortran90examplesourcefragment}
58 \end{figure}
59
60 For allocatable and pointer arrays, it is essentially required
61 by the Fortran 90 semantics that each array consist of two
62 parts, which we here call 1) the descriptor and 2) the raw
63 data. (A descriptor has often been called a dope vector in
64 other contexts, although it is often a structure of some kind
65 rather than a simple vector.) Because there are two parts,
66 and because the lifetime of the descriptor is necessarily
67 longer than and includes that of the raw data, there must be
68 an address somewhere in the descriptor that points to the
69 raw data when, in fact, there is some (that is, when 
70 the ``variable'' is allocated or associated).
71
72 For concreteness, suppose that a descriptor looks something
73 like the C structure in 
74 Figure \refersec{fig:fortran90exampledescriptorrepresentation}.
75 Note, however, that it is
76 a property of the design that 1) a debugger needs no builtin
77 knowledge of this structure and 2) there does not need to
78 be an explicit representation of this structure in the DWARF
79 input to the debugger.
80
81 \begin{figure}[here]
82 \begin{lstlisting}
83 struct desc {
84     long el_len; // Element length
85     void * base; // Address of raw data
86     int ptr_assoc : 1; // Pointer is associated flag
87     int ptr_alloc : 1; // Pointer is allocated flag
88     int num_dims : 6; // Number of dimensions
89     struct dims_str { // For each dimension...  
90         long low_bound;
91         long upper_bound;
92         long stride;
93     } dims[63];
94 };
95 \end{lstlisting}
96 \caption{Fortran 90 example: descriptor representation} \label{fig:fortran90exampledescriptorrepresentation}
97 \end{figure}
98
99
100 In practice, of course, a “real” descriptor will have
101 dimension substructures only for as many dimensions as are
102 specified in the num\_dims component. Let us use the notation
103 desc ,textless n \textgreater\   
104 to indicate a specialization of the desc struct in
105 which n is the bound for the dims component as well as the
106 contents of the num\_dims component.
107
108 Because the arrays considered here come in two parts, it is
109 necessary to distinguish the parts carefully. In particular,
110 the “address of the variable” or equivalently, the “base
111 address of the object” always refers to the descriptor. For
112 arrays that do not come in two parts, an implementation can
113 provide a descriptor anyway, thereby giving it two parts. (This
114 may be convenient for general runtime support unrelated to
115 debugging.) In this case the above vocabulary applies as
116 stated. Alternatively, an implementation can do without a
117 descriptor, in which case the “address of the variable”,
118 or equivalently the “base address of the object”, refers
119 to the “raw data” (the real data, the only thing around
120 that can be the object).
121
122 If an object has a descriptor, then the DWARF type for that
123 object will have a DW\_AT\_data\_location attribute. If an object
124 does not have a descriptor, then usually the DWARF type for the
125 object will not have a DW\_AT\_data\_location. (See the following
126 Ada example for a case where the type for an object without
127 a descriptor does have a DW\_AT\_data\_location attribute. In
128 that case the object doubles as its own descriptor.)
129
130 The Fortran 90 derived type array\_ptr can now be redescribed
131 in C\dash like terms that expose some of the representation as in
132
133 \begin{lstlisting}
134 struct array_ptr {
135     float myvar;
136     desc<1> ap;
137 };
138 \end{lstlisting}
139
140 Similarly for variable arrays:
141 \begin{lstlisting}
142 desc<1> arrays;
143 \end{lstlisting}
144
145 (Recall that desc \textless 1 \textgreater 
146 indicates the 1\dash dimensional version of desc.)
147
148 Finally, the following notation is useful:
149
150 \begin{enumerate}[1.]
151 \item  sizeof(type): size in bytes of entities of the given type
152
153 \item offset(type, comp): offset in bytes of the comp component
154 within an entity of the given type
155 \end{enumerate}
156
157
158 The DWARF description is shown in 
159 Section \refersec{app:fortran90exampledwarfdescription}.
160
161 \subsection{Fortran 90 example: DWARF description}
162 \label{app:fortran90exampledwarfdescription}
163
164 \begin{alltt}
165 ! Description for type of 'ap'
166
167 1\$: \addtoindex{DW\_TAG\_array\_type}
168         ! No name, default (Fortran) ordering, default stride
169         DW\_AT\_type(reference to REAL)
170         DW\_AT\_associated(expression= ! Test 'ptr\_assoc' flag
171             DW\_OP\_push\_object\_address
172             DW\_OP\_lit<n> ! where n == offset(ptr\_assoc)
173             DW\_OP\_plus
174             DW\_OP\_deref
175             DW\_OP\_lit1 ! mask for 'ptr\_assoc' flag
176             DW\_OP\_and)
177         DW\_AT\_data\_location(expression= ! Get raw data address
178             DW\_OP\_push\_object\_address
179             DW\_OP\_lit<n> ! where n == offset(base)
180             DW\_OP\_plus
181             DW\_OP\_deref) ! Type of index of array 'ap'
182 2\$:     \addtoindex{DW\_TAG\_subrange\_type}
183         ! No name, default stride
184         DW\_AT\_type(reference to INTEGER)
185         DW\_AT\_lower\_bound(expression=
186         DW\_OP\_push\_object\_address
187             DW\_OP\_lit<n> ! where n ==
188                          !  offset(desc, dims) +
189                          !  offset(dims\_str, lower\_bound)
190             DW\_OP\_plus
191             DW\_OP\_deref)
192         DW\_AT\_upper\_bound(expression=
193             DW\_OP\_push\_object\_address
194             DW\_OP\_lit<n> ! where n ==
195                          !  offset(desc, dims) +
196                          !  offset(dims\_str, upper\_bound)
197             DW\_OP\_plus
198             \addtoindex{DW\_OP\_deref})
199         !  Note: for the m'th dimension, the second operator becomes
200         !  DW\_OP\_lit<x> where
201         !  x == offset(desc, dims) +
202         !  (m-1)*sizeof(dims\_str) +
203         !  offset(dims\_str, [lower|upper]\_bound)
204         !  That is, the expression does not get longer for each
205         !  successive dimension (other than to express the larger
206         !  offsets involved).
207 3\$: DW\_TAG\_structure\_type
208         DW\_AT\_name("array\_ptr")
209         DW\_AT\_byte\_size(constant sizeof(REAL) + sizeof(desc<1>))
210 4\$:     DW\_TAG\_member
211             DW\_AT\_name("myvar")
212             DW\_AT\_type(reference to REAL)
213             DW\_AT\_data\_member\_location(constant 0)
214 5\$:     DW\_TAG\_member
215             DW\_AT\_name("ap");
216             DW\_AT\_type(reference to 1\$)
217             DW\_AT\_data\_member\_location(constant sizeof(REAL))
218
219 6\$: DW\_TAG\_array\_type
220         ! No name, default (Fortran) ordering, default stride
221         DW\_AT\_type(reference to 3\$)
222         DW\_AT\_allocated(expression=
223              ! Test 'ptr\_alloc' flag
224             DW\_OP\_push\_object\_address
225             DW\_OP\_lit<n> ! where n == offset(ptr\_alloc)
226             DW\_OP\_plus
227             DW\_OP\_deref
228             DW\_OP\_lit2
229              ! mask for 'ptr\_alloc' flag
230             DW\_OP\_and)
231         DW\_AT\_data\_location(expression= ! Get raw data address
232             DW\_OP\_push\_object\_address
233             DW\_OP\_lit<n> ! where n = offset(base)
234             DW\_OP\_plus
235             DW\_OP\_deref)
236
237 7\$: DW\_TAG\_subrange\_type
238         ! No name, default stride
239         DW\_AT\_type(reference to INTEGER)
240         DW\_AT\_lower\_bound(expression=
241             DW\_OP\_push\_object\_address
242             DW\_OP\_lit<n> ! where n == ...
243             DW\_OP\_plus
244             DW\_OP\_deref)
245         DW\_AT\_upper\_bound(expression=
246             DW\_OP\_push\_object\_address
247             DW\_OP\_lit<n> ! where n == ...
248             DW\_OP\_plus
249             DW\_OP\_deref)
250
251 8\$: DW\_TAG\_variable
252         DW\_AT\_name("arrays")
253         DW\_AT\_type(reference to 6\$)
254         DW\_AT\_location(expression=
255             ...as appropriate...) ! Assume static allocation
256 \end{alltt}
257
258 \subsection{Fortran 90 example continued: DWARF description}
259 \label{app:fortran90examplecontinueddwarfdescription}
260
261 Suppose the program is stopped immediately following completion
262 of the do loop. Suppose further that the user enters the
263 following debug command:
264
265 \begin{lstlisting}
266 debug> print arrays(5)%ap(2)
267 \end{lstlisting}
268
269 Interpretation of this expression proceeds as follows:
270
271 \begin{enumerate}[1.]
272
273 \item Lookup name arrays. We find that it is a variable,
274 whose type is given by the unnamed type at 6\$. Notice that
275 the type is an array type.
276
277
278 \item Find the 5 element of that array object. To do array
279 indexing requires several pieces of information:
280
281 \begin{enumerate}[a]
282
283 \item  the address of the array data
284
285 \item the lower bounds of the array \\
286 % Using plain [] here gives trouble.
287 \lbrack To check that 5 is within bounds would require the upper
288 bound too, but we will skip that for this example. \rbrack
289
290 \item the stride 
291
292 \end{enumerate}
293
294 For a), check for a DW\_AT\_data\_location attribute. Since
295 there is one, go execute the expression, whose result is
296 the address needed. The object address used in this case
297 is the object we are working on, namely the variable named
298 arrays , whose address was found in step 1. (Had there been
299 no DW\_AT\_data\_location attribute, the desired address would
300 be the same as the address from step 1.)
301
302 For b), for each dimension of the array (only one
303 in this case), go interpret the usual lower bound
304 attribute. Again this is an expression, which again begins
305 with DW\_OP\_push\_object\_address. This object is 
306 \textbf{still} arrays,
307 from step 1, because we have not begun to actually perform
308 any indexing yet.
309
310 For c), the default stride applies. Since there is no
311 DW\_AT\_byte\_stride attribute, use the size of the array element
312 type, which is the size of type array\_ptr (at 3\$).
313
314 Having acquired all the necessary data, perform the indexing
315 operation in the usual manner -  which has nothing to do with
316 any of the attributes involved up to now. Those just provide
317 the actual values used in the indexing step.
318
319 The result is an object within the memory that was dynamically
320 allocated for arrays.
321
322 \item  Find the ap component of the object just identified,
323 whose type is array\_ptr.
324
325 This is a conventional record component lookup and
326 interpretation. It happens that the ap component in this case
327 begins at offset 4 from the beginning of the containing object.
328 Component ap has the unnamed array type defined at 1\$ in the
329 symbol table.
330
331 \item  Find the second element of the array object found in step 3. To do array indexing requires
332 several pieces of information:
333
334 \begin{enumerate}[a]
335 \item  the address of the array storage
336
337 \item  the lower bounds of the array \\
338 % Using plain [] here gives trouble.
339 \lbrack To check that 2 is within bounds we would require the upper
340 %bound too, but we’ll skip that for this example \rbrack
341
342 \item  the stride
343
344 \end{enumerate}
345 \end{enumerate}
346
347 This is just like step 2), so the details are omitted. Recall
348 that because the DWARF type 1\$ has a DW\_AT\_data\_location,
349 the address that results from step 4) is that of a
350 descriptor, and that address is the address pushed by the
351 DW\_OP\_push\_object\_address operations in 1\$ and 2\$.
352
353 Note: we happen to be accessing a pointer array here instead
354 of an allocatable array; but because there is a common
355 underlying representation, the mechanics are the same. There
356 could be completely different descriptor arrangements and the
357 mechanics would still be the same — only the stack machines
358 would be different.
359
360
361
362 \subsection{Ada Example}
363 \label{app:adaexample}
364
365 Figure \refersec{fig:adaexamplesourcefragment}
366 illustrates two kinds of Ada parameterized array, one embedded in a record.
367
368
369 \begin{figure}[here]
370 \begin{lstlisting}
371 M : INTEGER := <exp>;
372 VEC1 : array (1..M) of INTEGER;
373 subtype TEENY is INTEGER range 1..100;
374 type ARR is array (INTEGER range <>) of INTEGER;
375 type REC2(N : TEENY := 100) is record
376     VEC2 : ARR(1..N);
377 end record;
378
379 OBJ2B : REC2;
380 \end{lstlisting}
381 \caption{Ada 90 example: source fragment} \label{fig:adaexamplesourcefragment}
382 \end{figure}
383
384 VEC1 illustrates an (unnamed) array type where the upper bound
385 of the first and only dimension is determined at runtime. Ada
386 semantics require that the value of an array bound is fixed at
387 the time the array type is elaborated (where elaboration refers
388 to the runtime executable aspects of type processing). For
389 the purposes of this example, we assume that there are no
390 other assignments to M so that it safe for the REC1 type
391 description to refer directly to that variable (rather than
392 a compiler generated copy).
393
394 REC2 illustrates another array type (the unnamed type of
395 component VEC2) where the upper bound of the first and only
396 bound is also determined at runtime. In this case, the upper
397 bound is contained in a discriminant of the containing record
398 type. (A discriminant is a component of a record whose value
399 cannot be changed independently of the rest of the record
400 because that value is potentially used in the specification
401 of other components of the record.)
402
403 The DWARF description is shown in 
404 Section \refersec{app:adaexampledwarfdescription}
405
406
407 Interesting aspects about this example are:
408
409 \begin{enumerate}[1)]
410 \item The array VEC2 is ``immediately'' contained within structure
411 REC2 (there is no intermediate descriptor or indirection),
412 which is reflected in the absence of a DW\_AT\_data\_location
413 attribute on the array type at 28\$.
414
415 \item One of the bounds of VEC2 is nonetheless dynamic and part of
416 the same containing record. It is described as a reference to
417 a member, and the location of the upper bound is determined
418 as for any member. That is, the location is determined using
419 an address calculation relative to the base of the containing
420 object.  A consumer must notice that the referenced bound is a
421 member of the same containing object and implicitly push the
422 base address of the containing object just as for accessing
423 a data member generally.
424
425 \item The lack of a subtype concept in DWARF means that DWARF types
426 serve the role of subtypes and must replicate information from
427 what should be the parent type. For this reason, DWARF for
428 the unconstrained array ARR is not needed for the purposes
429 of this example and therefore not shown.
430 \end{enumerate}
431
432 \subsubsection{Ada example: DWARF description}
433 \label{app:adaexampledwarfdescription}
434
435 \begin{alltt}
436 11\$: DW\_TAG\_variable
437         DW\_AT\_name("M")
438         DW\_AT\_type(reference to INTEGER)
439 12\$: DW\_TAG\_array\_type
440         ! No name, default (Ada) order, default stride
441         DW\_AT\_type(reference to INTEGER)
442 13\$:    DW\_TAG\_subrange\_type
443             DW\_AT\_type(reference to INTEGER)
444             DW\_AT\_lower\_bound(constant 1)
445             DW\_AT\_upper\_bound(reference to variable M at 11\$)
446 14\$: DW\_TAG\_variable
447         DW\_AT\_name("VEC1")
448         DW\_AT\_type(reference to array type at 12\$)
449     . . .
450 21\$: DW\_TAG\_subrange\_type
451         DW\_AT\_name("TEENY")
452         DW\_AT\_type(reference to INTEGER)
453         DW\_AT\_lower\_bound(constant 1)
454         DW\_AT\_upper\_bound(constant 100)
455
456       . . .
457 26\$: DW\_TAG\_structure\_type
458         DW\_AT\_name("REC2")
459 27\$:   DW\_TAG\_member
460             DW\_AT\_name("N")
461             DW\_AT\_type(reference to subtype TEENY at 21\$)
462             DW\_AT\_data\_member\_location(constant 0)
463 28\$:   DW\_TAG\_array\_type
464             ! No name, default (Ada) order, default stride
465             ! Default data location
466             DW\_AT\_TYPE(reference to INTEGER)
467 29\$:       DW\_TAG\_subrange\_type
468                 DW\_AT\_type(reference to subrange TEENY at 21\$)
469                 DW\_AT\_lower\_bound(constant 1)
470                 DW\_AT\_upper\_bound(reference to member N at 27\$)
471 30\$:   DW\_TAG\_member
472             DW\_AT\_name("VEC2")
473             DW\_AT\_type(reference to array “subtype” at 28\$)
474             DW\_AT\_data\_member\_location(machine=
475                 DW\_OP\_lit<n> ! where n == offset(REC2, VEC2)
476                 DW\_OP\_plus)
477       . . .
478 41\$: DW\_TAG\_variable
479         DW\_AT\_name("OBJ2B")
480         DW\_AT\_type(reference to REC2 at 26\$)
481         DW\_AT\_location(...as appropriate...)
482
483 \end{alltt}
484
485 \subsection{Pascal Example}
486 \label{app:pascalexample}
487
488 The Pascal source in 
489 Figure \refersec{fig:packedrecordexamplesourcefragment}
490 is used to illustrate the representation of packed unaligned bit
491 fields.
492 \begin{figure}[here]
493 \begin{lstlisting}
494 TYPE T : PACKED RECORD ! bit size is 2
495 F5 : BOOLEAN; ! bit offset is 0
496 F6 : BOOLEAN; ! bit offset is 1
497 END;
498 VAR V : PACKED RECORD
499 F1 : BOOLEAN; ! bit offset is 0
500 F2 : PACKED RECORD ! bit offset is 1
501 F3 : INTEGER; ! bit offset is 0 in F2, 1 in V
502 END;
503 F4 : PACKED ARRAY [0..1] OF T; ! bit offset is 33
504 F7 : T; ! bit offset is 37
505 END;
506 \end{lstlisting}
507 \caption{Packed record example: source fragment} \label{fig:packedrecordexamplesourcefragment}
508 \end{figure}
509
510 The DWARF representation in 
511 Section \refersec{app:packedrecordexampledwarfdescription} 
512 is
513 appropriate. 
514 DW\_TAG\_packed\_type entries could be added to
515 better represent the source, but these do not otherwise affect
516 the example and are omitted for clarity. Note that this same
517 representation applies to both typical big\dash \ and 
518 little\dash endian
519 architectures using the conventions described in 
520 Section \refersec{chap:datamemberentries}.
521
522
523 \subsection{Packed record example: DWARF description}
524 \label{app:packedrecordexampledwarfdescription}
525 \begin{alltt}
526
527 21\$: DW\_TAG\_structure\_type ! anonymous type for F2
528         DW\_TAG\_member
529             DW\_AT\_name("F3")
530             DW\_AT\_type(reference to 11\$)
531 22\$: DW\_TAG\_array\_type ! anonymous type for F4
532         DW\_AT\_type(reference to 20\$)
533         DW\_TAG\_subrange\_type
534             DW\_AT\_type(reference to 11\$)
535             DW\_AT\_lower\_bound(0)
536             DW\_AT\_upper\_bound(1)
537         DW\_AT\_bit\_stride(2)
538         DW\_AT\_bit\_size(4)
539 23\$: DW\_TAG\_structure\_type ! anonymous type for V
540         DW\_AT\_bit\_size(39)
541         DW\_TAG\_member
542             DW\_AT\_name("F1")
543             DW\_AT\_type(reference to 10\$)
544             DW\_AT\_data\_bit\_offset(0)! may be omitted
545             DW\_AT\_bit\_size(1) ! may be omitted
546         DW\_AT\_member
547             DW\_AT\_name("F2")
548             DW\_AT\_type(reference to 21\$)
549             DW\_AT\_data\_bit\_offset(1)
550             DW\_AT\_bit\_size(32) ! may be omitted
551         DW\_AT\_member
552             DW\_AT\_name("F4")
553             DW\_AT\_type(reference to 22\$)
554             DW\_AT\_data\_bit\_offset(33)
555             DW\_AT\_bit\_size(4) ! may be omitted
556         DW\_AT\_member
557             DW\_AT\_name("F7")
558             DW\_AT\_type(reference to 20\$) ! type T
559             DW\_AT\_data\_bit\_offset(37)
560             DW\_AT\_bit\_size(2) ! may be omitted
561      DW\_TAG\_variable
562         DW\_AT\_name("V")
563         DW\_AT\_type(reference to 23\$)
564         DW\_AT\_location(...)
565         ...
566 \end{alltt}
567
568 \section{Namespace Example}
569 \label{app:namespaceexample}
570
571
572 The C++ example in 
573 Figure \refersec{fig:namespaceexamplesourcefragment}
574 is used to illustrate the representation of namespaces.
575
576 \begin{figure}[here]
577 \begin{lstlisting}
578 namespace {
579     int i;
580 }
581
582 namespace A {
583     namespace B {
584         int j;
585         int myfunc (int a);
586         float myfunc (float f) { return f – 2.0; }
587         int myfunc2(int a) { return a + 2; }
588     }
589 }
590 namespace Y {
591     using A::B::j;         // (1) using declaration
592     int foo;
593 }
594
595 using A::B::j;             // (2) using declaration
596 namespace Foo = A::B;      // (3) namespace alias
597 using Foo::myfunc;         // (4) using declaration
598 using namespace Foo;       // (5) using directive
599 namespace A {
600     namespace B {
601         using namespace Y; // (6) using directive
602         int k;
603     }
604 }
605 int Foo::myfunc(int a)
606 {
607     i = 3;
608     j = 4;
609     return myfunc2(3) + j + i + a + 2;
610 }
611 \end{lstlisting}
612 \caption{Namespace example: source fragment} \label{fig:namespaceexamplesourcefragment}
613 \end{figure}
614
615
616 The DWARF representation in 
617 Section \refersec{app:namespaceexampledwarfdescription}
618 is appropriate.
619
620 \subsection{Namespace example: DWARF description}
621 \label{app:namespaceexampledwarfdescription}
622 \begin{alltt}
623
624 1\$:  DW\_TAG\_base\_type
625         DW\_AT\_name("int")
626         ...
627 2\$:  DW\_TAG\_base\_type
628         DW\_AT\_name("float")
629         ...
630 6\$:  DW\_TAG\_namespace
631         ! no DW\_AT\_name attribute
632 7\$:
633         DW\_TAG\_variable
634             DW\_AT\_name("i")
635             DW\_AT\_type(reference to 1\$)
636             DW\_AT\_location ...
637             ...
638 10\$: DW\_TAG\_namespace
639         DW\_AT\_name("A")
640 20\$:    DW\_TAG\_namespace
641             DW\_AT\_name("B")
642 30\$:        DW\_TAG\_variable
643                 DW\_AT\_name("j")
644                 DW\_AT\_type(reference to 1\$)
645                 DW\_AT\_location ...
646                 ...
647 34\$:        DW\_TAG\_subprogram
648                 DW\_AT\_name("myfunc")
649                 DW\_AT\_type(reference to 1\$)
650                 ...
651 36\$:        DW\_TAG\_subprogram
652                 DW\_AT\_name("myfunc")
653                 DW\_AT\_type(reference to 2\$)
654                 ...
655 38\$:        DW\_TAG\_subprogram
656                 DW\_AT\_name("myfunc2")
657                 DW\_AT\_low\_pc ...
658                 DW\_AT\_high\_pc ...
659                 \addtoindex{DW\_AT\_type}(reference to 1\$)
660                 ...
661
662 40\$: DW\_TAG\_namespace
663         DW\_AT\_name("Y")
664         DW\_TAG\_imported\_declaration    ! (1) using-declaration
665             DW\_AT\_import(reference to 30\$)
666         DW\_TAG\_variable
667             DW\_AT\_name("foo")
668             DW\_AT\_type(reference to 1\$)
669             DW\_AT\_location ...
670             ...
671      DW\_TAG\_imported\_declaration       ! (2) using declaration
672         DW\_AT\_import(reference to 30\$)
673         DW\_TAG\_imported\_declaration    ! (3) namespace alias
674             DW\_AT\_name("Foo")
675             DW\_AT\_import(reference to 20\$)
676         DW\_TAG\_imported\_declaration    ! (4) using declaration
677             DW\_AT\_import(reference to 34\$) ! - part 1
678         DW\_TAG\_imported\_declaration    ! (4) using declaration
679             DW\_AT\_import(reference to 36\$) !  - part 2
680         DW\_TAG\_imported\_module         ! (5) using directive
681             DW\_AT\_import(reference to 20\$)
682         DW\_TAG\_namespace
683             DW\_AT\_extension(reference to 10\$)
684             DW\_TAG\_namespace
685                 DW\_AT\_extension(reference to 20\$)
686                 DW\_TAG\_imported\_module ! (6) using directive
687                     DW\_AT\_import(reference to 40\$)
688                 DW\_TAG\_variable
689                     DW\_AT\_name("k")
690                     DW\_AT\_type(reference to 1\$)
691                     DW\_AT\_location ...
692                     ...
693 60\$: DW\_TAG\_subprogram
694         DW\_AT\_specification(reference to 34\$)
695         DW\_AT\_low\_pc ...
696         DW\_AT\_high\_pc ...
697         ...
698 \end{alltt}
699
700 \section{Member Function Example}
701 \label{app:memberfunctionexample}
702
703 Consider the member function example fragment in 
704 Figure \refersec{fig:memberfunctionexamplesourcefragment}.
705
706 \begin{figure}[here]
707 \begin{lstlisting}
708 class A
709 {
710     void func1(int x1);
711     void func2() const;
712     static void func3(int x3);
713 };
714 void A::func1(int x) {}
715 \end{lstlisting}
716 \caption{Member function example: source fragment} \label{fig:memberfunctionexamplesourcefragment}
717 \end{figure}
718
719
720
721 The DWARF representation in 
722 Section \refersec{app:memberfunctionexampledwarfdescription}
723 is appropriate.
724
725 \subsection{Member function example: DWARF description}
726 \label{app:memberfunctionexampledwarfdescription}
727
728
729 \begin{alltt}
730 1\$: DW\_TAG\_unspecified\_type
731         DW\_AT\_name("void")
732                 ...
733 2\$ DW\_TAG\_base\_type
734         DW\_AT\_name("int")
735         ...
736 3\$: DW\_TAG\_class\_type
737         DW\_AT\_name("A")
738         ...
739 4\$:    DW\_TAG\_pointer\_type
740             DW\_AT\_type(reference to 3\$)
741             ...
742 5\$:    DW\_TAG\_const\_type
743             DW\_AT\_type(reference to 3\$)
744             ...
745 6\$:    DW\_TAG\_pointer\_type
746             DW\_AT\_type(reference to 5\$)
747             ...
748
749 7\$:    DW\_TAG\_subprogram
750             DW\_AT\_declaration
751             DW\_AT\_name("func1")
752             DW\_AT\_type(reference to 1\$)
753             DW\_AT\_object\_pointer(reference to 8\$)
754                 ! References a formal parameter in this 
755                 ! member function
756             ...
757 8\$:        DW\_TAG\_formal\_parameter
758                 DW\_AT\_artificial(true)
759                 DW\_AT\_name("this")
760                 DW\_AT\_type(reference to 4\$)
761                     ! Makes type of 'this' as 'A*' =>
762                     ! func1 has not been marked const 
763                     ! or volatile
764                 DW\_AT\_location ...
765                 ...
766 9\$:        DW\_TAG\_formal\_parameter
767                 DW\_AT\_name(x1)
768                 DW\_AT\_type(reference to 2\$)
769                 ...
770 10\$:    DW\_TAG\_subprogram
771              DW\_AT\_declaration
772              DW\_AT\_name("func2")
773              DW\_AT\_type(reference to 1\$)
774              DW\_AT\_object\_pointer(reference to 11\$)
775              ! References a formal parameter in this 
776              ! member function
777              ...
778 11\$:        DW\_TAG\_formal\_parameter
779                  DW\_AT\_artificial(true)
780                  DW\_AT\_name("this")
781                  DW\_AT\_type(reference to 6\$)
782                      ! Makes type of 'this' as 'A const*' =>
783                  !     func2 marked as const
784                  DW\_AT\_location ...
785                  ...
786 12\$:    DW\_TAG\_subprogram
787              DW\_AT\_declaration
788              DW\_AT\_name("func3")
789              DW\_AT\_type(reference to 1\$)
790              ...
791                  ! No object pointer reference formal parameter
792                  ! implies func3 is static
793 13\$:        DW\_TAG\_formal\_parameter
794                  DW\_AT\_name(x3)
795                  DW\_AT\_type(reference to 2\$)
796                  ...
797 \end{alltt}
798
799 \section{Line Number Program Example}
800 \label{app:linenumberprogramexample}
801
802 Consider the simple source file and the resulting machine
803 code for the Intel 8086 processor in 
804 Figure \refersec{fig:linenumberprogramexamplemachinecode}.
805
806 \begin{figure}[here]
807 \begin{lstlisting}
808 1: int
809 2: main()
810     0x239: push pb
811     0x23a: mov bp,sp
812 3: {
813 4: printf("Omit needless words\n");
814     0x23c: mov ax,0xaa
815     0x23f: push ax
816     0x240: call _printf
817     0x243: pop cx
818 5: exit(0);
819     0x244: xor ax,ax
820     0x246: push ax
821     0x247: call _exit
822     0x24a: pop cx
823 6: }
824     0x24b: pop bp
825     0x24c: ret
826 7: 0x24d:
827 \end{lstlisting}
828 \caption{Line number program example: machine code} \label{fig:linenumberprogramexamplemachinecode}
829 \end{figure}
830
831 Suppose the line number program header includes the following
832 (header fields not needed below are not shown):
833
834
835
836 \begin{alltt}
837 version                    4
838 minimum_instruction_length 1
839 opcode_base               10 ! Opcodes 10-12 not needed
840 line_base                  1
841 line_range                15
842 \end{alltt}
843
844
845 Figure \refersec{tab:linenumberprogramexampleoneencoding}
846 shows one encoding of the line number program, which occupies
847 12 bytes (the opcode SPECIAL(m,n) indicates the special opcode
848 generated for a line increment of m and an address increment
849 of n).
850
851
852 \begin{centering}
853 \setlength{\extrarowheight}{0.1cm}
854 \begin{longtable}{lll}
855   \caption{Line number program example: one encoding} \label{tab:linenumberprogramexampleoneencoding} \\
856   \hline \\ \bfseries Opcode &\bfseries Operand &\bfseries Byte Stream \\ \hline
857 \endfirsthead
858   \bfseries Opcode &\bfseries Operand &\bfseries Byte Stream\\ \hline
859 \endhead
860   \hline \emph{Continued on next page}
861 \endfoot
862   \hline
863 \endlastfoot
864 DW\_LNS\_advance\_pc&LEB128(0x239)&0x2, 0xb9, 0x04 \\
865 SPECIAL(2, 0)&0xb  & \\
866 SPECIAL(2, 3)&0x38 & \\
867 SPECIAL(1, 8)&0x82 & \\
868 SPECIAL(1, 7)&0x73 & \\
869 DW\_LNS\_advance\_pc&LEB128(2)&0x2, 0x2 \\
870 DW\_LNE\_end\_sequence &&0x0, 0x1, 0x1 \\
871 \end{longtable}
872 \end{centering}
873
874
875 Figure 62  FIXME REF
876 shows an alternate 
877 encoding of the same program using 
878 standard opcodes to advance
879 the program counter; 
880 this encoding occupies 22 bytes.
881
882 \begin{centering}
883 \setlength{\extrarowheight}{0.1cm}
884 \begin{longtable}{lll}
885   \caption{Line number program example: alternate encoding} \label{tab:linenumberprogramexamplealternateencoding} \\
886   \hline \\ \bfseries Opcode &\bfseries Operand &\bfseries Byte Stream \\ \hline
887 \endfirsthead
888   \bfseries Opcode &\bfseries Operand &\bfseries Byte Stream\\ \hline
889 \endhead
890   \hline \emph{Continued on next page}
891 \endfoot
892   \hline
893 \endlastfoot
894 DW\_LNS\_fixed\_advance\_pc&0x239&0x9, 0x39, 0x2        \\
895 SPECIAL(2, 0)&& 0xb        \\
896 DW\_LNS\_fixed\_advance\_pc&0x3&0x9, 0x3, 0x0        \\
897 SPECIAL(2, 0)&&0xb        \\
898 DW\_LNS\_fixed\_advance\_pc&0x8&0x9, 0x8, 0x0        \\
899 SPECIAL(1, 0)&& 0xa        \\
900 DW\_LNS\_fixed\_advance\_pc&0x7&0x9, 0x7, 0x0        \\
901 SPECIAL(1, 0) && 0xa        \\
902 DW\_LNS\_fixed\_advance\_pc&0x2&0x9, 0x2, 0x0        \\
903 DW\_LNE\_end\_sequence&&0x0, 0x1, 0x1        \\
904 \end{longtable}
905 \end{centering}
906
907
908 \section{Call Frame Information Example}
909 \label{app:callframeinformationexample}
910
911 The following example uses a hypothetical RISC machine in
912 the style of the Motorola 88000.
913
914 \begin{itemize}
915 \item Memory is byte addressed.
916
917 \item Instructions are all 4 bytes each and word aligned.
918
919 \item Instruction operands are typically of the form:
920
921 \begin{alltt}
922 <destination.reg>, <source.reg>, <constant>
923 \end{alltt}
924
925 \item The address for the load and store instructions is computed
926 by adding the contents of the
927 source register with the constant.
928
929 \item There are 8 4\dash byte registers:
930
931 \begin{alltt}
932 R0 always 0
933 R1 holds return address on call
934 R2-R3 temp registers (not preserved on call)
935 R4-R6 preserved on call
936 R7 stack pointer.
937 \end{alltt}
938
939 \item  The stack grows in the negative direction.
940
941 \item The architectural ABI committee specifies that the
942 stack pointer (R7) is the same as the CFA
943
944 \end{itemize}
945
946 The following 
947 (Figure refersec{fig:callframeinformationexamplemachinecodefragments}
948 are two code fragments from a subroutine called
949 foo that uses a frame pointer (in addition to the stack
950 pointer). The first column values are byte addresses. 
951 % The \space is so we get a space after >
952 \textless~fs~\textgreater \  denotes the stack frame size in bytes, namely 12.
953
954
955 \begin{figure}[here]
956 \begin{lstlisting}
957        ;; start prologue
958 foo    sub R7, R7, <fs>        ; Allocate frame
959 foo+4  store R1, R7, (<fs>-4)  ; Save the return address
960 foo+8  store R6, R7, (<fs>-8)  ; Save R6
961 foo+12 add R6, R7, 0           ; R6 is now the Frame ptr
962 foo+16 store R4, R6, (<fs>-12) ; Save a preserved reg
963        ;; This subroutine does not change R5
964        ...
965        ;; Start epilogue (R7 is returned to entry value)
966 foo+64 load R4, R6, (<fs>-12)  ; Restore R4
967 foo+68 load R6, R7, (<fs>-8)   ; Restore R6
968 foo+72 load R1, R7, (<fs>-4)   ; Restore return address
969 foo+76 add R7, R7, <fs>        ; Deallocate frame
970 foo+80 jump R1 ; Return
971 foo+84
972 \end{lstlisting}
973 \caption{Call frame information example: machine code fragments} \label{fig:callframeinformationexamplemachinecodefragments}
974 \end{figure}
975
976
977 An abstract table 
978 (see Section \refersec{chap:structureofcallframeinformation}) 
979 for the foo subroutine
980 is shown in 
981 Table \refersec{tab:callframeinformationexampleconceptualmatrix}.
982 Figure 64. FIXME REF 
983 Corresponding fragments from the
984 .debug\_frame section are shown in 
985 Table \refersec{tab:callframeinformationexamplecommoninformationentryencoding}.
986
987 The following notations apply in 
988 Table \refersec{tab:callframeinformationexampleconceptualmatrix}:
989
990 \begin{alltt}
991 1. R8 is the return address
992 2. s = same\_value rule
993 3. u = undefined rule
994 4. rN = register(N) rule
995 5. cN = offset(N) rule
996 6. a = architectural rule
997 \end{alltt}
998
999 \begin{centering}
1000 \setlength{\extrarowheight}{0.1cm}
1001 \begin{longtable}{lllllllllll}
1002   \caption{Call frame inforation example: conceptual matrix} \label{tab:callframeinformationexampleconceptualmatrix} \\
1003   \hline \\ \bfseries Location & \bfseries CFA & \bfseries R0 & \bfseries R1 & \bfseries R2 & \bfseries R3 & \bfseries R4 & \bfseries R5 & \bfseries R6 & \bfseries R7 & \bfseries R8 \\ \hline
1004 \endfirsthead
1005   \bfseries Location &\bfseries CFA &\bfseries R0 & \bfseries R1 & \bfseries R2 &\bfseries R3 &\bfseries R4 &\bfseries R5 &\bfseries R6 &\bfseries R7 &\bfseries R8\\ \hline
1006 \endhead
1007   \hline \emph{Continued on next page}
1008 \endfoot
1009   \hline
1010 \endlastfoot
1011 foo&[R7]+0&s&u&u&u&s&s&s&a&r1 \\
1012 foo+4&[R7]+fs&s&u&u&u&s&s&s&a&r1 \\
1013 foo+8&[R7]+fs&s&u&u&u&s&s&s&a&c-4 \\
1014 foo+12&[R7]+fs&s&u&u&u&s&s&c-8&a&c-4 \\
1015 foo+16&[R6]+fs&s&u&u&u&s&s&c-8&a&c-4 \\
1016 foo+20&[R6]+fs&s&u&u&u&c-12&s&c-8&a&c-4 \\
1017 ...&&&&&&&&&& \\
1018 foo+64&[R6]+fs&s&u&u&u&c-12&s&c-8&a&c-4 \\
1019 foo+68&[R6]+fs&s&u&u&u&s&s&c-8&a&c-4  \\
1020 foo+72&[R7]+fs&s&u&u&u&s&s&s&a&c-4  \\
1021 foo+76&[R7]+fs&s&u&u&u&s&s&s&a&r1 \\
1022 foo+80&[R7]+0&s&u&u&u&s&s&s&a&r1 \\
1023 \end{longtable}
1024 \end{centering}
1025
1026
1027 \begin{centering}
1028 \setlength{\extrarowheight}{0.1cm}
1029 \begin{longtable}{lll}
1030   \caption{Call frame information example: common information entry encoding} \label{tab:callframeinformationexamplecommoninformationentryencoding} \\
1031   \hline \\ \bfseries Address &\bfseries Value &\bfseries Comment \\ \hline
1032 \endfirsthead
1033   \bfseries Address &\bfseries Value &\bfseries Comment \\ \hline
1034 \endhead
1035   \hline \emph{Continued on next page}
1036 \endfoot
1037   \hline
1038 \endlastfoot
1039 cie&36&length    \\
1040 cie+4&0xffffffff&CIE\_id    \\
1041 cie+8&4&version    \\
1042 cie+9&0&augmentation     \\
1043 cie+10&4&address size    \\
1044 cie+11&0&segment size    \\
1045 cie+12&4&code\_alignment\_factor, \textless caf \textgreater    \\
1046 cie+13&-4&data\_alignment\_factor, \textless daf \textgreater    \\
1047 cie+14&8&R8 is the return addr.    \\
1048 cie+15&DW\_CFA\_def\_cfa (7, 0)&CFA = [R7]+0    \\
1049 cie+18&DW\_CFA\_same\_value (0)&R0 not modified (=0)    \\
1050 cie+20&DW\_CFA\_undefined (1)&R1 scratch    \\
1051 cie+22&DW\_CFA\_undefined (2)&R2 scratch    \\
1052 cie+24&DW\_CFA\_undefined (3)&R3 scratch    \\
1053 cie+26&DW\_CFA\_same\_value (4)&R4 preserve    \\
1054 cie+28&DW\_CFA\_same\_value (5)&R5 preserve    \\
1055 cie+30&DW\_CFA\_same\_value (6)&R6 preserve    \\
1056 cie+32&DW\_CFA\_same\_value (7)&R7 preserve    \\
1057 cie+34&DW\_CFA\_register (8, 1)&R8 is in R1    \\
1058 cie+37&DW\_CFA\_nop&padding    \\
1059 cie+38&DW\_CFA\_nop& padding \\
1060 cie+39& DW\_CFA\_nop&padding  \\
1061 cie+40 &&  \\
1062 \end{longtable}
1063 \end{centering}
1064
1065
1066 The following notations apply in 
1067 Table \refersec{tab:callframeinformationexampleframedescriptionentryencoding}:
1068
1069 \begin{alltt}
1070 1. <fs> = frame size
1071 2. <caf> = code alignment factor
1072 3. <daf> = data alignment factor
1073 \end{alltt}
1074
1075
1076 \begin{centering}
1077 \setlength{\extrarowheight}{0.1cm}
1078 \begin{longtable}{lll}
1079   \caption{Call frame information example: frame description entry encoding} \label{tab:callframeinformationexampleframedescriptionentryencoding} \\
1080   \hline \\ \bfseries Address &\bfseries Value &\bfseries Comment \\ \hline
1081 \endfirsthead
1082   \bfseries Address &\bfseries Value &\bfseries Comment \\ \hline
1083 \endhead
1084   \hline \emph{Continued on next page}
1085 \endfoot
1086   \hline
1087 \endlastfoot
1088 fde&40&length \\
1089 fde+4&cie&CIE\_ptr \\
1090 fde+8&foo&initial\_location \\
1091 fde+12&84&address\_range \\
1092 fde+16&DW\_CFA\_advance\_loc(1)&instructions \\
1093 fde+17&DW\_CFA\_def\_cfa\_offset(12)& \textless fs \textgreater \\
1094 fde+19&DW\_CFA\_advance\_loc(1)&4/ \textless caf \textgreater \\
1095 fde+20&DW\_CFA\_offset(8,1)&-4/ \textless daf \textgreater (second parameter) \\
1096 fde+22&DW\_CFA\_advance\_loc(1)& \\
1097 fde+23&DW\_CFA\_offset(6,2)&-8/ \textless daf> \textgreater (2nd parameter)  \\
1098 fde+25&DW\_CFA\_advance\_loc(1) & \\
1099 fde+26&DW\_CFA\_def\_cfa\_register(6) & \\
1100 fde+28&DW\_CFA\_advance\_loc(1) & \\
1101 fde+29&DW\_CFA\_offset(4,3)&-12/ \textless daf \textgreater (2nd parameter) \\
1102 fde+31&DW\_CFA\_advance\_loc(12)&44/ \textless caf \textgreater \\
1103 fde+32&DW\_CFA\_restore(4)& \\
1104 fde+33&DW\_CFA\_advance\_loc(1) & \\
1105 fde+34&DW\_CFA\_restore(6) & \\
1106 fde+35&DW\_CFA\_def\_cfa\_register(7)  & \\
1107 fde+37&DW\_CFA\_advance\_loc(1) & \\
1108 fde+38&DW\_CFA\_restore(8) &\\
1109 fde+39&DW\_CFA\_advance\_loc(1) &\\
1110 fde+40&DW\_CFA\_def\_cfa\_offset(0)  &\\
1111 fde+42&DW\_CFA\_nop&padding \\
1112 fde+43&DW\_CFA\_nop&padding \\
1113 fde+44 && \\
1114 \end{longtable}
1115 \end{centering}
1116
1117 \section{Inlining Examples}
1118 \label{app:inliningexamples}
1119 The pseudo\dash source in 
1120 Figure \refersec{fig:inliningexamplespseudosourcefragment}
1121 is used to illustrate the
1122 use of DWARF to describe inlined subroutine calls. This
1123 example involves a nested subprogram INNER that makes uplevel
1124 references to the formal parameter and local variable of the
1125 containing subprogram OUTER.
1126
1127 \begin{figure}[here]
1128 \begin{lstlisting}
1129 inline procedure OUTER (OUTER_FORMAL : integer) =
1130     begin
1131     OUTER_LOCAL : integer;
1132     procedure INNER (INNER_FORMAL : integer) =
1133         begin
1134         INNER_LOCAL : integer;
1135         print(INNER_FORMAL + OUTER_LOCAL);
1136         end;
1137     INNER(OUTER_LOCAL);
1138     ...
1139     INNER(31);
1140     end;
1141 ! Call OUTER
1142 !
1143 OUTER(7);
1144 \end{lstlisting}
1145 \caption{Inlining examples: pseudo-source fragmment} \label{fig:inliningexamplespseudosourcefragment}
1146 \end{figure}
1147
1148
1149 There are several approaches that a compiler might take to
1150 inlining for this sort of example. This presentation considers
1151 three such approaches, all of which involve inline expansion
1152 of subprogram OUTER. (If OUTER is not inlined, the inlining
1153 reduces to a simpler single level subset of the two level
1154 approaches considered here.)
1155
1156 The approaches are:
1157
1158 \begin{itemize}[1.]
1159 \item  Inline both OUTER and INNER in all cases
1160
1161 \item Inline OUTER, multiple INNERs \\
1162 Treat INNER as a non\dash inlinable part of OUTER, compile and
1163 call a distinct normal version of INNER defined within each
1164 inlining of OUTER.
1165
1166 \item Inline OUTER, one INNER \\
1167 Compile INNER as a single normal subprogram which is called
1168 from every inlining of OUTER.
1169 \end{itemize}
1170
1171 This discussion does not consider why a compiler might choose
1172 one of these approaches; it considers only how to describe
1173 the result.
1174
1175 In the examples that follow in this section, the debugging
1176 information entries are given mnemonic labels of the following
1177 form
1178
1179 \begin{lstlisting}
1180 <io>.<ac>.<n>.<s>
1181 \end{lstlisting}
1182
1183 where \begin{verbatim}<io>\end{verbatim}
1184 is either INNER or OUTER to indicate to which
1185 subprogram the debugging information entry applies, 
1186 \begin{verbatim}<ac>\end{verbatim}
1187 is either AI or CI to indicate ``abstract instance'' or
1188 ``concrete instance'' respectively, 
1189 \begin{verbatim}<n>\end{verbatim}
1190 is the number of the
1191 alternative being considered, and 
1192 \begin{verbatim}<s>\end{verbatim}
1193 is a sequence number that
1194 distinguishes the individual entries. There is no implication
1195 that symbolic labels, nor any particular naming convention,
1196 are required in actual use.
1197
1198 For conciseness, declaration coordinates and call coordinates are omitted.
1199
1200 \subsection{Alternative 1: inline both OUTER and INNER}
1201 \label{app:inlinebothouterandinner}
1202
1203 A suitable abstract instance for an alternative where both
1204 OUTER and INNER are always inlined is shown in 
1205 Figure \refersec{app:inliningexample1abstractinstance}
1206
1207 Notice in 
1208 Section \refersec{app:inliningexample1abstractinstance} 
1209 that the debugging information entry for
1210 INNER (labelled INNER.AI.1.1) is nested in (is a child of)
1211 that for OUTER (labelled OUTER.AI.1.1). Nonetheless, the
1212 abstract instance tree for INNER is considered to be separate
1213 and distinct from that for OUTER.
1214
1215 The call of OUTER shown in 
1216 Figure \refersec{fig:inliningexamplespseudosourcefragment}
1217 might be described as
1218 shown in 
1219 Section \refersec{app:inliningexample1concreteinstance}.
1220
1221
1222 \subsubsection{Inlining example \#1: abstract instance}
1223 \label{app:inliningexample1abstractinstance}
1224 \begin{alltt}
1225     ! Abstract instance for OUTER
1226     !
1227 OUTER.AI.1.1:
1228     DW\_TAG\_subprogram
1229         DW\_AT\_name("OUTER")
1230         DW\_AT\_inline(DW\_INL\_declared\_inlined)
1231         ! No low/high PCs
1232 OUTER.AI.1.2:
1233         DW\_TAG\_formal\_parameter
1234             DW\_AT\_name("OUTER\_FORMAL")
1235             DW\_AT\_type(reference to integer)
1236             ! No location
1237 OUTER.AI.1.3:
1238         DW\_TAG\_variable
1239             DW\_AT\_name("OUTER\_LOCAL")
1240             DW\_AT\_type(reference to integer)
1241             ! No location
1242         !
1243         ! Abstract instance for INNER
1244         !
1245 INNER.AI.1.1:
1246         DW\_TAG\_subprogram
1247             DW\_AT\_name("INNER")
1248             DW\_AT\_inline(DW\_INL\_declared\_inlined)
1249             ! No low/high PCs
1250 INNER.AI.1.2:
1251             DW\_TAG\_formal\_parameter
1252                 DW\_AT\_name("INNER\_FORMAL")
1253                 DW\_AT\_type(reference to integer)
1254                 ! No location
1255 INNER.AI.1.3:
1256             DW\_TAG\_variable
1257                 DW\_AT\_name("INNER\_LOCAL")
1258                 DW\_AT\_type(reference to integer)
1259                 ! No location
1260             ...
1261             0
1262         ! No DW\_TAG\_inlined\_subroutine (concrete instance)
1263         ! for INNER corresponding to calls of INNER
1264         ...
1265         0
1266 \end{alltt}
1267
1268
1269 \subsubsection{Inlining example \#1: concrete instance}
1270 \label{app:inliningexample1concreteinstance}
1271 \begin{alltt}
1272 ! Concrete instance for call "OUTER(7)"
1273 !
1274 OUTER.CI.1.1:
1275     DW\_TAG\_inlined\_subroutine
1276         ! No name
1277         DW\_AT\_abstract\_origin(reference to OUTER.AI.1.1)
1278         DW\_AT\_low\_pc(...)
1279         DW\_AT\_high\_pc(...)
1280 OUTER.CI.1.2:
1281         DW\_TAG\_formal\_parameter
1282             ! No name
1283             DW\_AT\_abstract\_origin(reference to OUTER.AI.1.2)
1284             DW\_AT\_const\_value(7)
1285 OUTER.CI.1.3:
1286         DW\_TAG\_variable
1287             ! No name
1288             DW\_AT\_abstract\_origin(reference to OUTER.AI.1.3)
1289             DW\_AT\_location(...)
1290         !
1291         ! No DW\_TAG\_subprogram (abstract instance) for INNER
1292         !
1293         ! Concrete instance for call INNER(OUTER\_LOCAL)
1294         !
1295 INNER.CI.1.1:
1296         DW\_TAG\_inlined\_subroutine
1297             ! No name
1298             DW\_AT\_abstract\_origin(reference to INNER.AI.1.1)
1299             DW\_AT\_low\_pc(...)
1300             DW\_AT\_high\_pc(...)
1301             DW\_AT\_static\_link(...)
1302 INNER.CI.1.2:
1303             DW\_TAG\_formal\_parameter
1304                 ! No name
1305                 DW\_AT\_abstract\_origin(reference to INNER.AI.1.2)
1306                 DW\_AT\_location(...)
1307 INNER.CI.1.3:
1308              DW\_TAG\_variable
1309                 ! No name
1310                 DW\_AT\_abstract\_origin(reference to INNER.AI.1.3)
1311                 DW\_AT\_location(...)
1312             ...
1313             0
1314         ! Another concrete instance of INNER within OUTER
1315         ! for the call "INNER(31)"
1316         ...
1317         0
1318 \end{alltt}
1319
1320 \subsection{Alternative 2: Inline OUTER, multiple INNERs}
1321 \label{app:inlineoutermultiipleinners}
1322
1323
1324 In the second alternative we assume that subprogram INNER
1325 is not inlinable for some reason, but subprogram OUTER is
1326 inlinable. Each concrete inlined instance of OUTER has its
1327 own normal instance of INNER. The abstract instance for OUTER,
1328 which includes INNER, is shown in 
1329 Section \refersec{app:inliningexample2abstractinstance}.
1330
1331 Note that the debugging information in this Figure differs from
1332 that in 
1333 Section \refersec{app:inliningexample1abstractinstance}
1334 in that INNER lacks a DW\_AT\_inline attribute
1335 and therefore is not a distinct abstract instance. INNER
1336 is merely an out\dash of\dash line routine that is part of OUTER’s
1337 abstract instance. This is reflected in the Figure 70 by
1338 the fact that the labels for INNER use the substring OUTER
1339 instead of INNER.
1340
1341 A resulting concrete inlined instance of OUTER is shown in
1342 Section \refersec{app:inliningexample2concreteinstance}.
1343
1344 Notice in 
1345 Section \refersec{app:inliningexample2concreteinstance}.
1346 that OUTER is expanded as a concrete
1347 inlined instance, and that INNER is nested within it as a
1348 concrete out\dash of\dash line subprogram. Because INNER is cloned
1349 for each inline expansion of OUTER, only the invariant
1350 attributes of INNER 
1351 (for example, DW\_AT\_name) are specified
1352 in the abstract instance of OUTER, and the low\dash level,
1353 instance\dash specific attributes of INNER (for example,
1354 DW\_AT\_low\_pc) are specified in each concrete instance of OUTER.
1355
1356 The several calls of INNER within OUTER are compiled as normal
1357 calls to the instance of INNER that is specific to the same
1358 instance of OUTER that contains the calls.
1359
1360
1361 \subsubsection{Inlining example 2: abstract instance}
1362 \label{app:inliningexample2abstractinstance}
1363 \begin{alltt}
1364     ! Abstract instance for OUTER
1365     !
1366 OUTER.AI.2.1:
1367     DW\_TAG\_subprogram
1368         DW\_AT\_name("OUTER")
1369         DW\_AT\_inline(DW\_INL\_declared\_inlined)
1370         ! No low/high PCs
1371 OUTER.AI.2.2:
1372         DW\_TAG\_formal\_parameter
1373             DW\_AT\_name("OUTER\_FORMAL")
1374             DW\_AT\_type(reference to integer)
1375             ! No location
1376 OUTER.AI.2.3:
1377         DW\_TAG\_variable
1378             DW\_AT\_name("OUTER\_LOCAL")
1379             DW\_AT\_type(reference to integer)
1380             ! No location
1381         !
1382         ! Nested out-of-line INNER subprogram
1383         !
1384 OUTER.AI.2.4:
1385         DW\_TAG\_subprogram
1386             DW\_AT\_name("INNER")
1387             ! No DW\_AT\_inline
1388             ! No low/high PCs, frame\_base, etc.
1389 OUTER.AI.2.5:
1390             DW\_TAG\_formal\_parameter
1391                 DW\_AT\_name("INNER\_FORMAL")
1392                 DW\_AT\_type(reference to integer)
1393                 ! No location
1394 OUTER.AI.2.6:
1395             DW\_TAG\_variable
1396                 DW\_AT\_name("INNER\_LOCAL")
1397                 DW\_AT\_type(reference to integer)
1398                 ! No location
1399             ...
1400             0
1401         ...
1402         0
1403 \end{alltt}
1404
1405 \subsubsection{Inlining example 2: concrete instance}
1406 \label{app:inliningexample2concreteinstance}
1407 \begin{alltt}
1408
1409     ! Concrete instance for call "OUTER(7)"
1410     !
1411 OUTER.CI.2.1:
1412     DW\_TAG\_inlined\_subroutine
1413         ! No name
1414         DW\_AT\_abstract\_origin(reference to OUTER.AI.2.1)
1415         DW\_AT\_low\_pc(...)
1416         DW\_AT\_high\_pc(...)
1417 OUTER.CI.2.2:
1418         DW\_TAG\_formal\_parameter
1419             ! No name
1420             DW\_AT\_abstract\_origin(reference to OUTER.AI.2.2)
1421             DW\_AT\_location(...)
1422 OUTER.CI.2.3:
1423         DW\_TAG\_variable
1424             ! No name
1425             DW\_AT\_abstract\_origin(reference to OUTER.AI.2.3)
1426             DW\_AT\_location(...)
1427         !
1428         ! Nested out-of-line INNER subprogram
1429         !
1430 OUTER.CI.2.4:
1431         DW\_TAG\_subprogram
1432             ! No name
1433             DW\_AT\_abstract\_origin(reference to OUTER.AI.2.4)
1434             DW\_AT\_low\_pc(...)
1435             DW\_AT\_high\_pc(...)
1436             DW\_AT\_frame\_base(...)
1437             DW\_AT\_static\_link(...)
1438 OUTER.CI.2.5:
1439             DW\_TAG\_formal\_parameter
1440                 ! No name
1441                 DW\_AT\_abstract\_origin(reference to OUTER.AI.2.5)
1442                 DW\_AT\_location(...)
1443 OUTER.CI.2.6:
1444             DW\_TAG\_variable
1445                 ! No name
1446                 DW\_AT\_abstract\_origin(reference to OUTER.AT.2.6)
1447                 DW\_AT\_location(...)
1448             ...
1449             0
1450         ...
1451         0
1452 \end{alltt}
1453
1454 \subsection{Alternative 3: inline OUTER, one normal INNER}
1455 \label{app:inlineouteronenormalinner}
1456
1457 In the third approach, one normal subprogram for INNER is
1458 compiled which is called from all concrete inlined instances of
1459 OUTER. The abstract instance for OUTER is shown in 
1460 Section \refersec{app:inliningexample3abstractinstance}.
1461
1462 The most distinctive aspect of that Figure is that subprogram
1463 INNER exists only within the abstract instance of OUTER,
1464 and not in OUTER’s concrete instance. In the abstract
1465 instance of OUTER, the description of INNER has the full
1466 complement of attributes that would be expected for a
1467 normal subprogram. While attributes such as DW\_AT\_low\_pc,
1468 DW\_AT\_high\_pc, DW\_AT\_location, and so on, typically are omitted
1469 from an abstract instance because they are not invariant across
1470 instances of the containing abstract instance, in this case
1471 those same attributes are included precisely because they are
1472 invariant -- there is only one subprogram INNER to be described
1473 and every description is the same.
1474
1475 A concrete inlined instance of OUTER is illustrated in
1476 \refersec{app:inliningexample3concreteinstance}.
1477
1478 Notice in 
1479 Figure 73 FIXME REF
1480 \refersec{app:inliningexample3concreteinstance}
1481 that there is no DWARF representation for
1482 INNER at all; the representation of INNER does not vary across
1483 instances of OUTER and the abstract instance of OUTER includes
1484 the complete description of INNER, so that the description of
1485 INNER may be (and for reasons of space efficiency, should be)
1486 omitted from each concrete instance of OUTER.
1487
1488 There is one aspect of this approach that is problematical from
1489 the DWARF perspective. The single compiled instance of INNER
1490 is assumed to access up\dash level variables of OUTER; however,
1491 those variables may well occur at varying positions within
1492 the frames that contain the concrete inlined instances. A
1493 compiler might implement this in several ways, including the
1494 use of additional compiler generated parameters that provide
1495 reference parameters for the up\dash level variables, or a compiler
1496 generated static link like parameter that points to the group
1497 of up\dash level entities, among other possibilities. In either of
1498 these cases, the DWARF description for the location attribute
1499 of each uplevel variable needs to be different if accessed
1500 from within INNER compared to when accessed from within the
1501 instances of OUTER. An implementation is likely to require
1502 vendor\dash specific DWARF attributes and/or debugging information
1503 entries to describe such cases.
1504
1505 Note that in C++, a member function of a class defined within
1506 a function definition does not require any vendor\dash specific
1507 extensions because the C++ language disallows access to
1508 entities that would give rise to this problem. (Neither extern
1509 variables nor static members require any form of static link
1510 for accessing purposes.)
1511
1512 \subsubsection{Inlining example 3: abstract instance}
1513 \label{app:inliningexample3abstractinstance}
1514 \begin{alltt}
1515     ! Abstract instance for OUTER
1516     !
1517 OUTER.AI.3.1:
1518     DW\_TAG\_subprogram
1519         DW\_AT\_name("OUTER")
1520         DW\_AT\_inline(DW\_INL\_declared\_inlined)
1521         ! No low/high PCs
1522 OUTER.AI.3.2:
1523         DW\_TAG\_formal\_parameter
1524             DW\_AT\_name("OUTER\_FORMAL")
1525             DW\_AT\_type(reference to integer)
1526             ! No location
1527 OUTER.AI.3.3:
1528         DW\_TAG\_variable
1529             DW\_AT\_name("OUTER\_LOCAL")
1530             DW\_AT\_type(reference to integer)
1531             ! No location
1532         !
1533         ! Normal INNER
1534         !
1535 OUTER.AI.3.4:
1536         DW\_TAG\_subprogram
1537             DW\_AT\_name("INNER")
1538             DW\_AT\_low\_pc(...)
1539             DW\_AT\_high\_pc(...)
1540             DW\_AT\_frame\_base(...)
1541             DW\_AT\_static\_link(...)
1542 OUTER.AI.3.5:
1543             DW\_TAG\_formal\_parameter
1544                 DW\_AT\_name("INNER\_FORMAL")
1545                 DW\_AT\_type(reference to integer)
1546                 DW\_AT\_location(...)
1547 OUTER.AI.3.6:
1548             DW\_TAG\_variable
1549                 DW\_AT\_name("INNER\_LOCAL")
1550                 DW\_AT\_type(reference to integer)
1551                 DW\_AT\_location(...)
1552             ...
1553             0
1554         ...
1555         0
1556 \end{alltt}
1557
1558
1559 \subsubsection{Inlining example 3: concrete instance}
1560 \label{app:inliningexample3concreteinstance}
1561 \begin{alltt}
1562     ! Concrete instance for call "OUTER(7)"
1563     !
1564 OUTER.CI.3.1:
1565     DW\_TAG\_inlined\_subroutine
1566         ! No name
1567         DW\_AT\_abstract\_origin(reference to OUTER.AI.3.1)
1568         DW\_AT\_low\_pc(...)
1569         DW\_AT\_high\_pc(...)
1570         DW\_AT\_frame\_base(...)
1571 OUTER.CI.3.2:
1572         DW\_TAG\_formal\_parameter
1573             ! No name
1574             DW\_AT\_abstract\_origin(reference to OUTER.AI.3.2)
1575             ! No type
1576             DW\_AT\_location(...)
1577 OUTER.CI.3.3:
1578         DW\_TAG\_variable
1579             ! No name
1580             DW\_AT\_abstract\_origin(reference to OUTER.AI.3.3)
1581             ! No type
1582             DW\_AT\_location(...)
1583         ! No DW\_TAG\_subprogram for "INNER"
1584         ...
1585         0
1586 \end{alltt}
1587
1588 \section{Constant Expression Example}
1589 \label{app:constantexpressionexample}
1590 C++ generalizes the notion of constant expressions to include
1591 constant expression user-defined literals and functions.
1592
1593 \begin{figure}[here]
1594 \begin{lstlisting}
1595 constexpr double mass = 9.8;
1596 constexpr int square (int x) { return x * x; }
1597 float arr[square(9)]; // square() called and inlined
1598 \end{lstlisting}
1599 \caption{Constant expressions: C++ source} \label{fig:constantexpressionscsource}
1600 \end{figure}
1601
1602 These declarations can be represented as illustrated in 
1603 Section \refersec{app:constantexpressionsdwarfdescription}.
1604
1605 \subsection{Constant expressions: DWARF description}
1606 \label{app:constantexpressionsdwarfdescription}
1607 \begin{alltt}
1608
1609       ! For variable mass
1610       !
1611 1\$:  DW\_TAG\_const\_type
1612         DW\_AT\_type(reference to "double")
1613 2\$:  DW\_TAG\_variable
1614         DW\_AT\_name("mass")
1615         DW\_AT\_type(reference to 1\$)
1616         DW\_AT\_const\_expr(true)
1617         DW\_AT\_const\_value(9.8)
1618       ! Abstract instance for square
1619       !
1620 10\$: DW\_TAG\_subprogram
1621         DW\_AT\_name("square")
1622         DW\_AT\_type(reference to "int")
1623         DW\_AT\_inline(DW\_INL\_inlined)
1624 11\$:   DW\_TAG\_formal\_parameter
1625             DW\_AT\_name("x")
1626             DW\_AT\_type(reference to "int")
1627       ! Concrete instance for square(9)
1628       !
1629 20\$: DW\_TAG\_inlined\_subroutine
1630         DW\_AT\_abstract\_origin(reference to 10\$)
1631         DW\_AT\_const\_expr(present)
1632         DW\_AT\_const\_value(81)
1633         DW\_TAG\_formal\_parameter
1634             DW\_AT\_abstract\_origin(reference to 11\$)
1635             DW\_AT\_const\_value(9)
1636       ! Anonymous array type for arr
1637       !
1638 30\$: DW\_TAG\_array\_type
1639         DW\_AT\_type(reference to "float")
1640         DW\_AT\_byte\_size(324) ! 81*4
1641         DW\_TAG\_subrange\_type
1642             DW\_AT\_type(reference to "int")
1643             DW\_AT\_upper\_bound(reference to 20\$)
1644       ! Variable arr
1645       !
1646 40\$: DW\_TAG\_variable
1647         DW\_AT\_name("arr")
1648         DW\_AT\_type(reference to 30\$)
1649 \end{alltt}
1650
1651
1652 \section{Unicode Character Example}
1653 \label{app:unicodecharacterexample}
1654
1655 Unicode character encodings can be described in DWARF as
1656 illustrated in 
1657 Section \refersec{app:unicodecharacterexamplesub}.
1658
1659 \begin{lstlisting}
1660 // C++ source
1661 //
1662 char16_t chr_a = u'h';
1663 char32_t chr_b = U'h';
1664 \end{lstlisting}
1665
1666 \subsection{Unicode Character Example}
1667 \label{app:unicodecharacterexamplesub}
1668 \begin{alltt}
1669
1670 ! DWARF description
1671 !
1672 1\$: DW\_TAG\_base\_type
1673         DW\_AT\_name("char16\_t")
1674         DW\_AT\_encoding(DW\_ATE\_UTF)
1675         DW\_AT\_byte\_size(2)
1676 2\$: DW\_TAG\_base\_type
1677         DW\_AT\_name("char32\_t")
1678         DW\_AT\_encoding(DW\_ATE\_UTF)
1679         DW\_AT\_byte\_size(4)
1680 3\$: DW\_TAG\_variable
1681         DW\_AT\_name("chr\_a")
1682         DW\_AT\_type(reference to 1\$)
1683 4\$: DW\_TAG\_variable
1684         DW\_AT\_name("chr\_b")
1685         DW\_AT\_type(reference to 2\$)
1686 \end{alltt}
1687
1688
1689
1690 \section{Type-Safe Enumeration Example}
1691 \label{app:typesafeenumerationexample}
1692
1693
1694 C++ type\dash safe enumerations can be described in DWARF as illustrated in 
1695 Section \refersec{app:ctypesafeenumerationexample}.
1696
1697 \begin{lstlisting}
1698 // C++ source
1699 //
1700 enum class E { E1, E2=100 };
1701 E e1;
1702 \end{lstlisting}
1703
1704 \subsection{C++ type-safe enumeration example}
1705 \label{app:ctypesafeenumerationexample}
1706 \begin{alltt}
1707 ! DWARF description
1708 !
1709 11\$: DW\_TAG\_enumeration\_type
1710         DW\_AT\_name("E")
1711         DW\_AT\_type(reference to "int")
1712         DW\_AT\_enum\_class(present)
1713 12\$:   DW\_TAG\_enumerator
1714             DW\_AT\_name("E1")
1715             DW\_AT\_const\_value(0)
1716 13\$:
1717          DW\_TAG\_enumerator
1718             DW\_AT\_name("E2")
1719             DW\_AT\_const\_value(100)
1720 14\$: DW\_TAG\_variable
1721         DW\_AT\_name("e1")
1722         DW\_AT\_type(reference to 11\$)
1723 \end{alltt}
1724
1725 \section{Template Example}
1726 \label{app:templateexample}
1727
1728 C++ templates can be described in DWARF as illustrated in 
1729 Section \refersec{app:ctemplateexample1}.
1730
1731
1732
1733 \begin{lstlisting}
1734 // C++ source
1735 //
1736 template<class T>
1737 struct wrapper {
1738     T comp;
1739 };
1740 wrapper<int> obj;
1741 \end{lstlisting}
1742
1743 \subsection{C++ template example 1}
1744 \label{app:ctemplateexample1}
1745 \begin{alltt}
1746 ! DWARF description
1747 !
1748 11\$: DW\_TAG\_structure\_type
1749         DW\_AT\_name("wrapper")
1750 12\$: DW\_TAG\_template\_type\_parameter
1751         DW\_AT\_name("T")
1752         DW\_AT\_type(reference to "int")
1753 13\$ DW\_TAG\_member
1754         DW\_AT\_name("comp")
1755         DW\_AT\_type(reference to 12\$)
1756 14\$: DW\_TAG\_variable
1757         DW\_AT\_name("obj")
1758         DW\_AT\_type(reference to 11\$)
1759 \end{alltt}
1760
1761 The actual type of the component comp is int, but in the DWARF
1762 the type references the DW\_TAG\_template\_type\_parameter for
1763 T, which in turn references int. This implies that in the
1764 original template comp was of type T and that was replaced
1765 with int in the instance.  There exist situations where it is
1766 not possible for the DWARF to imply anything about the nature
1767 of the original template. 
1768
1769 Consider following C++ source and DWARF 
1770 that can describe it in
1771 Section \refersec{app:ctemplateexample2}.
1772
1773
1774 \begin{lstlisting}
1775 // C++ source
1776 //
1777     template<class T>
1778     struct wrapper {
1779         T comp;
1780     };
1781     template<class U>
1782     void consume(wrapper<U> formal)
1783     {
1784         ...
1785     }
1786     wrapper<int> obj;
1787     consume(obj);
1788 \end{lstlisting}
1789
1790 \subsection{C++ template example 2}
1791 \label{app:ctemplateexample2}
1792 \begin{alltt}
1793 ! DWARF description
1794 !
1795 11\$: DW\_TAG\_structure\_type
1796         DW\_AT\_name("wrapper")
1797 12\$:   DW\_TAG\_template\_type\_parameter
1798             DW\_AT\_name("T")
1799             DW\_AT\_type(reference to "int")
1800 13\$    DW\_TAG\_member
1801             DW\_AT\_name("comp")
1802             DW\_AT\_type(reference to 12\$)
1803 14\$: DW\_TAG\_variable
1804         DW\_AT\_name("obj")
1805         DW\_AT\_type(reference to 11\$)
1806 21\$: DW\_TAG\_subprogram
1807         DW\_AT\_name("consume")
1808 22\$:   DW\_TAG\_template\_type\_parameter
1809             DW\_AT\_name("U")
1810             DW\_AT\_type(reference to "int")
1811 23\$:   DW\_TAG\_formal\_parameter
1812             DW\_AT\_name("formal")
1813             DW\_AT\_type(reference to 11\$)
1814 \end{alltt}
1815
1816 In the DW\_TAG\_subprogram entry for the instance of consume,
1817 U is described as 
1818 int. 
1819 The type of formal is 
1820 \begin{alltt}
1821 wrapper<U>
1822 \end{alltt}
1823  in
1824 the source. DWARF only represents instantiations of templates;
1825 there is no entry which represents 
1826 \begin{alltt}
1827 wrapper<U>, 
1828 \end{alltt}
1829 which is neither
1830 a template parameter nor a template instantiation. The type
1831 of formal is described as 
1832 \begin{alltt}
1833 wrapper<int>, 
1834 \end{alltt}
1835 the instantiation of
1836 \begin{alltt}
1837 wrapper<U>, 
1838 \end{alltt}
1839 in the DW\_AT\_type attribute at 
1840 23\$. 
1841 There is no
1842 description of the relationship between template type parameter
1843 T at 12\$ and U at 
1844 22\$ which was used to instantiate 
1845 \begin{alltt}
1846 wrapper<U>.
1847 \end{alltt}
1848
1849 A consequence of this is that the DWARF information would
1850 not distinguish between the existing example and one where
1851 the formal of consume were declared in the source to be
1852 \begin{alltt}
1853 wrapper<int>.
1854 \end{alltt}
1855
1856 \section{Template Alias Examples}
1857 \label{app:templatealiasexample}
1858
1859 C++ template aliases can be described in DWARF as illustrated in 
1860 Section \refersec{app:templatealiasexample1}
1861 and 
1862 Section \refersec{app:templatealiasexample2}.
1863
1864
1865 \begin{lstlisting}
1866 // C++ source, template alias example 1
1867 //
1868 template<typename T, typename U>
1869 struct Alpha {
1870     T tango;
1871     U uniform;
1872 };
1873 template<typename V> using Beta = Alpha<V,V>;
1874 Beta<long> b;
1875 \end{lstlisting}
1876
1877
1878 \subsection{template alias example 1}
1879 \label{app:templatealiasexample1}
1880 \begin{alltt}
1881 ! DWARF representation for variable 'b'
1882 !
1883 20\$: DW\_TAG\_structure\_type
1884         DW\_AT\_name("Alpha")
1885 21\$:   DW\_TAG\_template\_type\_parameter
1886             DW\_AT\_name("T")
1887             DW\_AT\_type(reference to "long")
1888 22\$:   DW\_TAG\_template\_type\_parameter
1889             DW\_AT\_name("U")
1890             DW\_AT\_type(reference to "long")
1891 23\$:   DW\_TAG\_member
1892             DW\_AT\_name("tango")
1893             DW\_AT\_type(reference to 21\$)
1894 24\$:   DW\_TAG\_member
1895             DW\_AT\_name("uniform")
1896             DW\_AT\_type(reference to 22\$)
1897 25\$: DW\_TAG\_template\_alias
1898         DW\_AT\_name("Beta")
1899         DW\_AT\_type(reference to 20\$)
1900 26\$:   DW\_TAG\_template\_type\_parameter
1901             DW\_AT\_name("V")
1902             DW\_AT\_type(reference to "long")
1903 27\$: DW\_TAG\_variable
1904         DW\_AT\_name("b")
1905         DW\_AT\_type(reference to 25\$)
1906 \end{alltt}
1907
1908
1909 \begin{lstlisting}
1910 // C++ source, template alias example 2
1911 //
1912 template<class TX> struct X { };
1913 template<class TY> struct Y { };
1914 template<class T> using Z = Y<T>;
1915 X<Y<int>> y;
1916 X<Z<int>> z;
1917 \end{lstlisting}
1918
1919
1920 \subsection{template alias example 2}
1921 \label{app:templatealiasexample2}
1922 \begin{alltt}
1923 ! DWARF representation for X<Y<int>>
1924 !
1925 30\$: DW\_TAG\_structure\_type
1926         DW\_AT\_name("Y")
1927 31\$:   DW\_TAG\_template\_type\_parameter
1928             DW\_AT\_name("TY")
1929             DW\_AT\_type(reference to "int")
1930 32\$: DW\_TAG\_structure\_type
1931         DW\_AT\_name("X")
1932 33\$:   DW\_TAG\_template\_type\_parameter
1933             DW\_AT\_name("TX")
1934             DW\_AT\_type(reference to 30\$)
1935
1936 ! DWARF representation for X<Z<int>>
1937 !
1938 40\$: DW\_TAG\_template\_alias
1939 using Z = Y<int>;
1940         DW\_AT\_name("Z")
1941         DW\_AT\_type(reference to 30\$)
1942 41\$:   DW\_TAG\_template\_type\_parameter
1943             DW\_AT\_name("T")
1944             DW\_AT\_type(reference to "int")
1945 42\$: DW\_TAG\_structure\_type
1946         DW\_AT\_name("X")
1947 43\$:   DW\_TAG\_template\_type\_parameter
1948             DW\_AT\_name("TX")
1949             DW\_AT\_type(reference to 40\$)
1950 ! Note that 32\$ and 42\$ are actually the same type
1951 !
1952 50\$: DW\_TAG\_variable
1953         DW\_AT\_name("y")
1954         DW\_AT\_type(reference to \$32)
1955 51\$: DW\_TAG\_variable
1956         DW\_AT\_name("z")
1957         DW\_AT\_type(reference to \$42)
1958 \end{alltt}