1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21/*
22 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
23 * Use is subject to license terms.
24 */
25
26/*
27 * DWARF to tdata conversion
28 *
29 * For the most part, conversion is straightforward, proceeding in two passes.
30 * On the first pass, we iterate through every die, creating new type nodes as
31 * necessary.  Referenced tdesc_t's are created in an uninitialized state, thus
32 * allowing type reference pointers to be filled in.  If the tdesc_t
33 * corresponding to a given die can be completely filled out (sizes and offsets
34 * calculated, and so forth) without using any referenced types, the tdesc_t is
35 * marked as resolved.  Consider an array type.  If the type corresponding to
36 * the array contents has not yet been processed, we will create a blank tdesc
37 * for the contents type (only the type ID will be filled in, relying upon the
38 * later portion of the first pass to encounter and complete the referenced
39 * type).  We will then attempt to determine the size of the array.  If the
40 * array has a byte size attribute, we will have completely characterized the
41 * array type, and will be able to mark it as resolved.  The lack of a byte
42 * size attribute, on the other hand, will prevent us from fully resolving the
43 * type, as the size will only be calculable with reference to the contents
44 * type, which has not, as yet, been encountered.  The array type will thus be
45 * left without the resolved flag, and the first pass will continue.
46 *
47 * When we begin the second pass, we will have created tdesc_t nodes for every
48 * type in the section.  We will traverse the tree, from the iidescs down,
49 * processing each unresolved node.  As the referenced nodes will have been
50 * populated, the array type used in our example above will be able to use the
51 * size of the referenced types (if available) to determine its own type.  The
52 * traversal will be repeated until all types have been resolved or we have
53 * failed to make progress.  When all tdescs have been resolved, the conversion
54 * is complete.
55 *
56 * There are, as always, a few special cases that are handled during the first
57 * and second passes:
58 *
59 *  1. Empty enums - GCC will occasionally emit an enum without any members.
60 *     Later on in the file, it will emit the same enum type, though this time
61 *     with the full complement of members.  All references to the memberless
62 *     enum need to be redirected to the full definition.  During the first
63 *     pass, each enum is entered in dm_enumhash, along with a pointer to its
64 *     corresponding tdesc_t.  If, during the second pass, we encounter a
65 *     memberless enum, we use the hash to locate the full definition.  All
66 *     tdescs referencing the empty enum are then redirected.
67 *
68 *  2. Forward declarations - If the compiler sees a forward declaration for
69 *     a structure, followed by the definition of that structure, it will emit
70 *     DWARF data for both the forward declaration and the definition.  We need
71 *     to resolve the forward declarations when possible, by redirecting
72 *     forward-referencing tdescs to the actual struct/union definitions.  This
73 *     redirection is done completely within the first pass.  We begin by
74 *     recording all forward declarations in dw_fwdhash.  When we define a
75 *     structure, we check to see if there have been any corresponding forward
76 *     declarations.  If so, we redirect the tdescs which referenced the forward
77 *     declarations to the structure or union definition.
78 *
79 * XXX see if a post traverser will allow the elimination of repeated pass 2
80 * traversals.
81 */
82
83#include <stdio.h>
84#include <stdlib.h>
85#include <string.h>
86#include <strings.h>
87#include <errno.h>
88#include <libelf.h>
89#include <libdwarf.h>
90#include <libgen.h>
91#include <dwarf.h>
92
93#include "ctf_headers.h"
94#include "ctftools.h"
95#include "memory.h"
96#include "list.h"
97#include "traverse.h"
98
99/*
100 * We need to define a couple of our own intrinsics, to smooth out some of the
101 * differences between the GCC and DevPro DWARF emitters.  See the referenced
102 * routines and the special cases in the file comment for more details.
103 *
104 * Type IDs are 32 bits wide.  We're going to use the top of that field to
105 * indicate types that we've created ourselves.
106 */
107#define	TID_FILEMAX		0x3fffffff	/* highest tid from file */
108#define	TID_VOID		0x40000001	/* see die_void() */
109#define	TID_LONG		0x40000002	/* see die_array() */
110
111#define	TID_MFGTID_BASE		0x40000003	/* first mfg'd tid */
112
113/*
114 * To reduce the staggering amount of error-handling code that would otherwise
115 * be required, the attribute-retrieval routines handle most of their own
116 * errors.  If the following flag is supplied as the value of the `req'
117 * argument, they will also handle the absence of a requested attribute by
118 * terminating the program.
119 */
120#define	DW_ATTR_REQ	1
121
122#define	TDESC_HASH_BUCKETS	511
123
124typedef struct dwarf {
125	Dwarf_Debug dw_dw;		/* for libdwarf */
126	Dwarf_Error dw_err;		/* for libdwarf */
127	Dwarf_Off dw_maxoff;		/* highest legal offset in this cu */
128	tdata_t *dw_td;			/* root of the tdesc/iidesc tree */
129	hash_t *dw_tidhash;		/* hash of tdescs by t_id */
130	hash_t *dw_fwdhash;		/* hash of fwd decls by name */
131	hash_t *dw_enumhash;		/* hash of memberless enums by name */
132	tdesc_t *dw_void;		/* manufactured void type */
133	tdesc_t *dw_long;		/* manufactured long type for arrays */
134	size_t dw_ptrsz;		/* size of a pointer in this file */
135	tid_t dw_mfgtid_last;		/* last mfg'd type ID used */
136	uint_t dw_nunres;		/* count of unresolved types */
137	char *dw_cuname;		/* name of compilation unit */
138} dwarf_t;
139
140static void die_create_one(dwarf_t *, Dwarf_Die);
141static void die_create(dwarf_t *, Dwarf_Die);
142
143static tid_t
144mfgtid_next(dwarf_t *dw)
145{
146	return (++dw->dw_mfgtid_last);
147}
148
149static void
150tdesc_add(dwarf_t *dw, tdesc_t *tdp)
151{
152	hash_add(dw->dw_tidhash, tdp);
153}
154
155static tdesc_t *
156tdesc_lookup(dwarf_t *dw, int tid)
157{
158	tdesc_t tmpl;
159	void *tdp;
160
161	tmpl.t_id = tid;
162
163	if (hash_find(dw->dw_tidhash, &tmpl, &tdp))
164		return (tdp);
165	else
166		return (NULL);
167}
168
169/*
170 * Resolve a tdesc down to a node which should have a size.  Returns the size,
171 * zero if the size hasn't yet been determined.
172 */
173static size_t
174tdesc_size(tdesc_t *tdp)
175{
176	for (;;) {
177		switch (tdp->t_type) {
178		case INTRINSIC:
179		case POINTER:
180		case ARRAY:
181		case FUNCTION:
182		case STRUCT:
183		case UNION:
184		case ENUM:
185			return (tdp->t_size);
186
187		case FORWARD:
188			return (0);
189
190		case TYPEDEF:
191		case VOLATILE:
192		case CONST:
193		case RESTRICT:
194			tdp = tdp->t_tdesc;
195			continue;
196
197		case 0: /* not yet defined */
198			return (0);
199
200		default:
201			terminate("tdp %u: tdesc_size on unknown type %d\n",
202			    tdp->t_id, tdp->t_type);
203		}
204	}
205}
206
207static size_t
208tdesc_bitsize(tdesc_t *tdp)
209{
210	for (;;) {
211		switch (tdp->t_type) {
212		case INTRINSIC:
213			return (tdp->t_intr->intr_nbits);
214
215		case ARRAY:
216		case FUNCTION:
217		case STRUCT:
218		case UNION:
219		case ENUM:
220		case POINTER:
221			return (tdp->t_size * NBBY);
222
223		case FORWARD:
224			return (0);
225
226		case TYPEDEF:
227		case VOLATILE:
228		case RESTRICT:
229		case CONST:
230			tdp = tdp->t_tdesc;
231			continue;
232
233		case 0: /* not yet defined */
234			return (0);
235
236		default:
237			terminate("tdp %u: tdesc_bitsize on unknown type %d\n",
238			    tdp->t_id, tdp->t_type);
239		}
240	}
241}
242
243static tdesc_t *
244tdesc_basetype(tdesc_t *tdp)
245{
246	for (;;) {
247		switch (tdp->t_type) {
248		case TYPEDEF:
249		case VOLATILE:
250		case RESTRICT:
251		case CONST:
252			tdp = tdp->t_tdesc;
253			break;
254		case 0: /* not yet defined */
255			return (NULL);
256		default:
257			return (tdp);
258		}
259	}
260}
261
262static Dwarf_Off
263die_off(dwarf_t *dw, Dwarf_Die die)
264{
265	Dwarf_Off off;
266
267	if (dwarf_dieoffset(die, &off, &dw->dw_err) == DW_DLV_OK)
268		return (off);
269
270	terminate("failed to get offset for die: %s\n",
271	    dwarf_errmsg(dw->dw_err));
272	/*NOTREACHED*/
273	return (0);
274}
275
276static Dwarf_Die
277die_sibling(dwarf_t *dw, Dwarf_Die die)
278{
279	Dwarf_Die sib;
280	int rc;
281
282	if ((rc = dwarf_siblingof(dw->dw_dw, die, &sib, &dw->dw_err)) ==
283	    DW_DLV_OK)
284		return (sib);
285	else if (rc == DW_DLV_NO_ENTRY)
286		return (NULL);
287
288	terminate("die %llu: failed to find type sibling: %s\n",
289	    die_off(dw, die), dwarf_errmsg(dw->dw_err));
290	/*NOTREACHED*/
291	return (NULL);
292}
293
294static Dwarf_Die
295die_child(dwarf_t *dw, Dwarf_Die die)
296{
297	Dwarf_Die child;
298	int rc;
299
300	if ((rc = dwarf_child(die, &child, &dw->dw_err)) == DW_DLV_OK)
301		return (child);
302	else if (rc == DW_DLV_NO_ENTRY)
303		return (NULL);
304
305	terminate("die %llu: failed to find type child: %s\n",
306	    die_off(dw, die), dwarf_errmsg(dw->dw_err));
307	/*NOTREACHED*/
308	return (NULL);
309}
310
311static Dwarf_Half
312die_tag(dwarf_t *dw, Dwarf_Die die)
313{
314	Dwarf_Half tag;
315
316	if (dwarf_tag(die, &tag, &dw->dw_err) == DW_DLV_OK)
317		return (tag);
318
319	terminate("die %llu: failed to get tag for type: %s\n",
320	    die_off(dw, die), dwarf_errmsg(dw->dw_err));
321	/*NOTREACHED*/
322	return (0);
323}
324
325static Dwarf_Attribute
326die_attr(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, int req)
327{
328	Dwarf_Attribute attr;
329	int rc;
330
331	if ((rc = dwarf_attr(die, name, &attr, &dw->dw_err)) == DW_DLV_OK) {
332		return (attr);
333	} else if (rc == DW_DLV_NO_ENTRY) {
334		if (req) {
335			terminate("die %llu: no attr 0x%x\n", die_off(dw, die),
336			    name);
337		} else {
338			return (NULL);
339		}
340	}
341
342	terminate("die %llu: failed to get attribute for type: %s\n",
343	    die_off(dw, die), dwarf_errmsg(dw->dw_err));
344	/*NOTREACHED*/
345	return (NULL);
346}
347
348static int
349die_signed(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, Dwarf_Signed *valp,
350    int req)
351{
352	*valp = 0;
353	if (dwarf_attrval_signed(die, name, valp, &dw->dw_err) != DW_DLV_OK) {
354		if (req)
355			terminate("die %llu: failed to get signed: %s\n",
356			    die_off(dw, die), dwarf_errmsg(dw->dw_err));
357		return (0);
358	}
359
360	return (1);
361}
362
363static int
364die_unsigned(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, Dwarf_Unsigned *valp,
365    int req)
366{
367	*valp = 0;
368	if (dwarf_attrval_unsigned(die, name, valp, &dw->dw_err) != DW_DLV_OK) {
369		if (req)
370			terminate("die %llu: failed to get unsigned: %s\n",
371			    die_off(dw, die), dwarf_errmsg(dw->dw_err));
372		return (0);
373	}
374
375	return (1);
376}
377
378static int
379die_bool(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, Dwarf_Bool *valp, int req)
380{
381	*valp = 0;
382
383	if (dwarf_attrval_flag(die, name, valp, &dw->dw_err) != DW_DLV_OK) {
384		if (req)
385			terminate("die %llu: failed to get flag: %s\n",
386			    die_off(dw, die), dwarf_errmsg(dw->dw_err));
387		return (0);
388	}
389
390	return (1);
391}
392
393static int
394die_string(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, char **strp, int req)
395{
396	const char *str = NULL;
397
398	if (dwarf_attrval_string(die, name, &str, &dw->dw_err) != DW_DLV_OK ||
399	    str == NULL) {
400		if (req)
401			terminate("die %llu: failed to get string: %s\n",
402			    die_off(dw, die), dwarf_errmsg(dw->dw_err));
403		else
404			*strp = NULL;
405		return (0);
406	} else
407		*strp = xstrdup(str);
408
409	return (1);
410}
411
412static Dwarf_Off
413die_attr_ref(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name)
414{
415	Dwarf_Off off;
416
417	if (dwarf_attrval_unsigned(die, name, &off, &dw->dw_err) != DW_DLV_OK) {
418		terminate("die %llu: failed to get ref: %s\n",
419		    die_off(dw, die), dwarf_errmsg(dw->dw_err));
420	}
421
422	return (off);
423}
424
425static char *
426die_name(dwarf_t *dw, Dwarf_Die die)
427{
428	char *str = NULL;
429
430	(void) die_string(dw, die, DW_AT_name, &str, 0);
431	if (str == NULL)
432		str = xstrdup("");
433
434	return (str);
435}
436
437static int
438die_isdecl(dwarf_t *dw, Dwarf_Die die)
439{
440	Dwarf_Bool val;
441
442	return (die_bool(dw, die, DW_AT_declaration, &val, 0) && val);
443}
444
445static int
446die_isglobal(dwarf_t *dw, Dwarf_Die die)
447{
448	Dwarf_Signed vis;
449	Dwarf_Bool ext;
450
451	/*
452	 * Some compilers (gcc) use DW_AT_external to indicate function
453	 * visibility.  Others (Sun) use DW_AT_visibility.
454	 */
455	if (die_signed(dw, die, DW_AT_visibility, &vis, 0))
456		return (vis == DW_VIS_exported);
457	else
458		return (die_bool(dw, die, DW_AT_external, &ext, 0) && ext);
459}
460
461static tdesc_t *
462die_add(dwarf_t *dw, Dwarf_Off off)
463{
464	tdesc_t *tdp = xcalloc(sizeof (tdesc_t));
465
466	tdp->t_id = off;
467
468	tdesc_add(dw, tdp);
469
470	return (tdp);
471}
472
473static tdesc_t *
474die_lookup_pass1(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name)
475{
476	Dwarf_Off ref = die_attr_ref(dw, die, name);
477	tdesc_t *tdp;
478
479	if ((tdp = tdesc_lookup(dw, ref)) != NULL)
480		return (tdp);
481
482	return (die_add(dw, ref));
483}
484
485static int
486die_mem_offset(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name,
487    Dwarf_Unsigned *valp, int req __unused)
488{
489	Dwarf_Locdesc *loc = NULL;
490	Dwarf_Signed locnum = 0;
491	Dwarf_Attribute at;
492	Dwarf_Half form;
493
494	if (name != DW_AT_data_member_location)
495		terminate("die %llu: can only process attribute "
496		    "DW_AT_data_member_location\n", die_off(dw, die));
497
498	if ((at = die_attr(dw, die, name, 0)) == NULL)
499		return (0);
500
501	if (dwarf_whatform(at, &form, &dw->dw_err) != DW_DLV_OK)
502		return (0);
503
504	switch (form) {
505	case DW_FORM_sec_offset:
506	case DW_FORM_block:
507	case DW_FORM_block1:
508	case DW_FORM_block2:
509	case DW_FORM_block4:
510		/*
511		 * GCC in base and Clang (3.3 or below) generates
512		 * DW_AT_data_member_location attribute with DW_FORM_block*
513		 * form. The attribute contains one DW_OP_plus_uconst
514		 * operator. The member offset stores in the operand.
515		 */
516		if (dwarf_loclist(at, &loc, &locnum, &dw->dw_err) != DW_DLV_OK)
517			return (0);
518		if (locnum != 1 || loc->ld_s->lr_atom != DW_OP_plus_uconst) {
519			terminate("die %llu: cannot parse member offset with "
520			    "operator other than DW_OP_plus_uconst\n",
521			    die_off(dw, die));
522		}
523		*valp = loc->ld_s->lr_number;
524		if (loc != NULL) {
525			dwarf_dealloc(dw->dw_dw, loc->ld_s, DW_DLA_LOC_BLOCK);
526			dwarf_dealloc(dw->dw_dw, loc, DW_DLA_LOCDESC);
527		}
528		break;
529
530	case DW_FORM_data1:
531	case DW_FORM_data2:
532	case DW_FORM_data4:
533	case DW_FORM_data8:
534	case DW_FORM_udata:
535		/*
536		 * Clang 3.4 generates DW_AT_data_member_location attribute
537		 * with DW_FORM_data* form (constant class). The attribute
538		 * stores a contant value which is the member offset.
539		 *
540		 * However, note that DW_FORM_data[48] in DWARF version 2 or 3
541		 * could be used as a section offset (offset into .debug_loc in
542		 * this case). Here we assume the attribute always stores a
543		 * constant because we know Clang 3.4 does this and GCC in
544		 * base won't emit DW_FORM_data[48] for this attribute. This
545		 * code will remain correct if future vesrions of Clang and
546		 * GCC conform to DWARF4 standard and only use the form
547		 * DW_FORM_sec_offset for section offset.
548		 */
549		if (dwarf_attrval_unsigned(die, name, valp, &dw->dw_err) !=
550		    DW_DLV_OK)
551			return (0);
552		break;
553
554	default:
555		terminate("die %llu: cannot parse member offset with form "
556		    "%u\n", die_off(dw, die), form);
557	}
558
559	return (1);
560}
561
562static tdesc_t *
563tdesc_intr_common(dwarf_t *dw, int tid, const char *name, size_t sz)
564{
565	tdesc_t *tdp;
566	intr_t *intr;
567
568	intr = xcalloc(sizeof (intr_t));
569	intr->intr_type = INTR_INT;
570	intr->intr_signed = 1;
571	intr->intr_nbits = sz * NBBY;
572
573	tdp = xcalloc(sizeof (tdesc_t));
574	tdp->t_name = xstrdup(name);
575	tdp->t_size = sz;
576	tdp->t_id = tid;
577	tdp->t_type = INTRINSIC;
578	tdp->t_intr = intr;
579	tdp->t_flags = TDESC_F_RESOLVED;
580
581	tdesc_add(dw, tdp);
582
583	return (tdp);
584}
585
586/*
587 * Manufacture a void type.  Used for gcc-emitted stabs, where the lack of a
588 * type reference implies a reference to a void type.  A void *, for example
589 * will be represented by a pointer die without a DW_AT_type.  CTF requires
590 * that pointer nodes point to something, so we'll create a void for use as
591 * the target.  Note that the DWARF data may already create a void type.  Ours
592 * would then be a duplicate, but it'll be removed in the self-uniquification
593 * merge performed at the completion of DWARF->tdesc conversion.
594 */
595static tdesc_t *
596tdesc_intr_void(dwarf_t *dw)
597{
598	if (dw->dw_void == NULL)
599		dw->dw_void = tdesc_intr_common(dw, TID_VOID, "void", 0);
600
601	return (dw->dw_void);
602}
603
604static tdesc_t *
605tdesc_intr_long(dwarf_t *dw)
606{
607	if (dw->dw_long == NULL) {
608		dw->dw_long = tdesc_intr_common(dw, TID_LONG, "long",
609		    dw->dw_ptrsz);
610	}
611
612	return (dw->dw_long);
613}
614
615/*
616 * Used for creating bitfield types.  We create a copy of an existing intrinsic,
617 * adjusting the size of the copy to match what the caller requested.  The
618 * caller can then use the copy as the type for a bitfield structure member.
619 */
620static tdesc_t *
621tdesc_intr_clone(dwarf_t *dw, tdesc_t *old, size_t bitsz)
622{
623	tdesc_t *new = xcalloc(sizeof (tdesc_t));
624
625	if (!(old->t_flags & TDESC_F_RESOLVED)) {
626		terminate("tdp %u: attempt to make a bit field from an "
627		    "unresolved type\n", old->t_id);
628	}
629
630	new->t_name = xstrdup(old->t_name);
631	new->t_size = old->t_size;
632	new->t_id = mfgtid_next(dw);
633	new->t_type = INTRINSIC;
634	new->t_flags = TDESC_F_RESOLVED;
635
636	new->t_intr = xcalloc(sizeof (intr_t));
637	bcopy(old->t_intr, new->t_intr, sizeof (intr_t));
638	new->t_intr->intr_nbits = bitsz;
639
640	tdesc_add(dw, new);
641
642	return (new);
643}
644
645static void
646tdesc_array_create(dwarf_t *dw, Dwarf_Die dim, tdesc_t *arrtdp,
647    tdesc_t *dimtdp)
648{
649	Dwarf_Unsigned uval;
650	Dwarf_Signed sval;
651	tdesc_t *ctdp = NULL;
652	Dwarf_Die dim2;
653	ardef_t *ar;
654
655	if ((dim2 = die_sibling(dw, dim)) == NULL) {
656		ctdp = arrtdp;
657	} else if (die_tag(dw, dim2) == DW_TAG_subrange_type) {
658		ctdp = xcalloc(sizeof (tdesc_t));
659		ctdp->t_id = mfgtid_next(dw);
660		debug(3, "die %llu: creating new type %u for sub-dimension\n",
661		    die_off(dw, dim2), ctdp->t_id);
662		tdesc_array_create(dw, dim2, arrtdp, ctdp);
663	} else {
664		terminate("die %llu: unexpected non-subrange node in array\n",
665		    die_off(dw, dim2));
666	}
667
668	dimtdp->t_type = ARRAY;
669	dimtdp->t_ardef = ar = xcalloc(sizeof (ardef_t));
670
671	/*
672	 * Array bounds can be signed or unsigned, but there are several kinds
673	 * of signless forms (data1, data2, etc) that take their sign from the
674	 * routine that is trying to interpret them.  That is, data1 can be
675	 * either signed or unsigned, depending on whether you use the signed or
676	 * unsigned accessor function.  GCC will use the signless forms to store
677	 * unsigned values which have their high bit set, so we need to try to
678	 * read them first as unsigned to get positive values.  We could also
679	 * try signed first, falling back to unsigned if we got a negative
680	 * value.
681	 */
682	if (die_unsigned(dw, dim, DW_AT_upper_bound, &uval, 0))
683		ar->ad_nelems = uval + 1;
684	else if (die_signed(dw, dim, DW_AT_upper_bound, &sval, 0))
685		ar->ad_nelems = sval + 1;
686	else if (die_unsigned(dw, dim, DW_AT_count, &uval, 0))
687		ar->ad_nelems = uval;
688	else if (die_signed(dw, dim, DW_AT_count, &sval, 0))
689		ar->ad_nelems = sval;
690	else
691		ar->ad_nelems = 0;
692
693	/*
694	 * Different compilers use different index types.  Force the type to be
695	 * a common, known value (long).
696	 */
697	ar->ad_idxtype = tdesc_intr_long(dw);
698	ar->ad_contents = ctdp;
699
700	if (ar->ad_contents->t_size != 0) {
701		dimtdp->t_size = ar->ad_contents->t_size * ar->ad_nelems;
702		dimtdp->t_flags |= TDESC_F_RESOLVED;
703	}
704}
705
706/*
707 * Create a tdesc from an array node.  Some arrays will come with byte size
708 * attributes, and thus can be resolved immediately.  Others don't, and will
709 * need to wait until the second pass for resolution.
710 */
711static void
712die_array_create(dwarf_t *dw, Dwarf_Die arr, Dwarf_Off off, tdesc_t *tdp)
713{
714	tdesc_t *arrtdp = die_lookup_pass1(dw, arr, DW_AT_type);
715	Dwarf_Unsigned uval;
716	Dwarf_Die dim;
717
718	debug(3, "die %llu <%llx>: creating array\n", off, off);
719
720	if ((dim = die_child(dw, arr)) == NULL ||
721	    die_tag(dw, dim) != DW_TAG_subrange_type)
722		terminate("die %llu: failed to retrieve array bounds\n", off);
723
724	tdesc_array_create(dw, dim, arrtdp, tdp);
725
726	if (die_unsigned(dw, arr, DW_AT_byte_size, &uval, 0)) {
727		tdesc_t *dimtdp;
728		int flags;
729
730		tdp->t_size = uval;
731
732		/*
733		 * Ensure that sub-dimensions have sizes too before marking
734		 * as resolved.
735		 */
736		flags = TDESC_F_RESOLVED;
737		for (dimtdp = tdp->t_ardef->ad_contents;
738		    dimtdp->t_type == ARRAY;
739		    dimtdp = dimtdp->t_ardef->ad_contents) {
740			if (!(dimtdp->t_flags & TDESC_F_RESOLVED)) {
741				flags = 0;
742				break;
743			}
744		}
745
746		tdp->t_flags |= flags;
747	}
748
749	debug(3, "die %llu <%llx>: array nelems %u size %u\n", off, off,
750	    tdp->t_ardef->ad_nelems, tdp->t_size);
751}
752
753/*ARGSUSED1*/
754static int
755die_array_resolve(tdesc_t *tdp, tdesc_t **tdpp __unused, void *private)
756{
757	dwarf_t *dw = private;
758	size_t sz;
759
760	if (tdp->t_flags & TDESC_F_RESOLVED)
761		return (1);
762
763	debug(3, "trying to resolve array %d (cont %d)\n", tdp->t_id,
764	    tdp->t_ardef->ad_contents->t_id);
765
766	if ((sz = tdesc_size(tdp->t_ardef->ad_contents)) == 0 &&
767	    (tdp->t_ardef->ad_contents->t_flags & TDESC_F_RESOLVED) == 0) {
768		debug(3, "unable to resolve array %s (%d) contents %d\n",
769		    tdesc_name(tdp), tdp->t_id,
770		    tdp->t_ardef->ad_contents->t_id);
771
772		dw->dw_nunres++;
773		return (1);
774	}
775
776	tdp->t_size = sz * tdp->t_ardef->ad_nelems;
777	tdp->t_flags |= TDESC_F_RESOLVED;
778
779	debug(3, "resolved array %d: %u bytes\n", tdp->t_id, tdp->t_size);
780
781	return (1);
782}
783
784/*ARGSUSED1*/
785static int
786die_array_failed(tdesc_t *tdp, tdesc_t **tdpp __unused, void *private __unused)
787{
788	tdesc_t *cont = tdp->t_ardef->ad_contents;
789
790	if (tdp->t_flags & TDESC_F_RESOLVED)
791		return (1);
792
793	fprintf(stderr, "Array %d: failed to size contents type %s (%d)\n",
794	    tdp->t_id, tdesc_name(cont), cont->t_id);
795
796	return (1);
797}
798
799/*
800 * Most enums (those with members) will be resolved during this first pass.
801 * Others - those without members (see the file comment) - won't be, and will
802 * need to wait until the second pass when they can be matched with their full
803 * definitions.
804 */
805static void
806die_enum_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
807{
808	Dwarf_Die mem;
809	Dwarf_Unsigned uval;
810	Dwarf_Signed sval;
811
812	if (die_isdecl(dw, die)) {
813		tdp->t_type = FORWARD;
814		return;
815	}
816
817	debug(3, "die %llu: creating enum\n", off);
818
819	tdp->t_type = ENUM;
820
821	(void) die_unsigned(dw, die, DW_AT_byte_size, &uval, DW_ATTR_REQ);
822	tdp->t_size = uval;
823
824	if ((mem = die_child(dw, die)) != NULL) {
825		elist_t **elastp = &tdp->t_emem;
826
827		do {
828			elist_t *el;
829
830			if (die_tag(dw, mem) != DW_TAG_enumerator) {
831				/* Nested type declaration */
832				die_create_one(dw, mem);
833				continue;
834			}
835
836			el = xcalloc(sizeof (elist_t));
837			el->el_name = die_name(dw, mem);
838
839			if (die_signed(dw, mem, DW_AT_const_value, &sval, 0)) {
840				el->el_number = sval;
841			} else if (die_unsigned(dw, mem, DW_AT_const_value,
842			    &uval, 0)) {
843				el->el_number = uval;
844			} else {
845				terminate("die %llu: enum %llu: member without "
846				    "value\n", off, die_off(dw, mem));
847			}
848
849			debug(3, "die %llu: enum %llu: created %s = %d\n", off,
850			    die_off(dw, mem), el->el_name, el->el_number);
851
852			*elastp = el;
853			elastp = &el->el_next;
854
855		} while ((mem = die_sibling(dw, mem)) != NULL);
856
857		hash_add(dw->dw_enumhash, tdp);
858
859		tdp->t_flags |= TDESC_F_RESOLVED;
860
861		if (tdp->t_name != NULL) {
862			iidesc_t *ii = xcalloc(sizeof (iidesc_t));
863			ii->ii_type = II_SOU;
864			ii->ii_name = xstrdup(tdp->t_name);
865			ii->ii_dtype = tdp;
866
867			iidesc_add(dw->dw_td->td_iihash, ii);
868		}
869	}
870}
871
872static int
873die_enum_match(void *arg1, void *arg2)
874{
875	tdesc_t *tdp = arg1, **fullp = arg2;
876
877	if (tdp->t_emem != NULL) {
878		*fullp = tdp;
879		return (-1); /* stop the iteration */
880	}
881
882	return (0);
883}
884
885/*ARGSUSED1*/
886static int
887die_enum_resolve(tdesc_t *tdp, tdesc_t **tdpp __unused, void *private)
888{
889	dwarf_t *dw = private;
890	tdesc_t *full = NULL;
891
892	if (tdp->t_flags & TDESC_F_RESOLVED)
893		return (1);
894
895	(void) hash_find_iter(dw->dw_enumhash, tdp, die_enum_match, &full);
896
897	/*
898	 * The answer to this one won't change from iteration to iteration,
899	 * so don't even try.
900	 */
901	if (full == NULL) {
902		terminate("tdp %u: enum %s has no members\n", tdp->t_id,
903		    tdesc_name(tdp));
904	}
905
906	debug(3, "tdp %u: enum %s redirected to %u\n", tdp->t_id,
907	    tdesc_name(tdp), full->t_id);
908
909	tdp->t_flags |= TDESC_F_RESOLVED;
910
911	return (1);
912}
913
914static int
915die_fwd_map(void *arg1, void *arg2)
916{
917	tdesc_t *fwd = arg1, *sou = arg2;
918
919	debug(3, "tdp %u: mapped forward %s to sou %u\n", fwd->t_id,
920	    tdesc_name(fwd), sou->t_id);
921	fwd->t_tdesc = sou;
922
923	return (0);
924}
925
926/*
927 * Structures and unions will never be resolved during the first pass, as we
928 * won't be able to fully determine the member sizes.  The second pass, which
929 * have access to sizing information, will be able to complete the resolution.
930 */
931static void
932die_sou_create(dwarf_t *dw, Dwarf_Die str, Dwarf_Off off, tdesc_t *tdp,
933    int type, const char *typename)
934{
935	Dwarf_Unsigned sz, bitsz, bitoff;
936#if BYTE_ORDER == _LITTLE_ENDIAN
937	Dwarf_Unsigned bysz;
938#endif
939	Dwarf_Die mem;
940	mlist_t *ml, **mlastp;
941	iidesc_t *ii;
942
943	tdp->t_type = (die_isdecl(dw, str) ? FORWARD : type);
944
945	debug(3, "die %llu: creating %s %s\n", off,
946	    (tdp->t_type == FORWARD ? "forward decl" : typename),
947	    tdesc_name(tdp));
948
949	if (tdp->t_type == FORWARD) {
950		hash_add(dw->dw_fwdhash, tdp);
951		return;
952	}
953
954	(void) hash_find_iter(dw->dw_fwdhash, tdp, die_fwd_map, tdp);
955
956	(void) die_unsigned(dw, str, DW_AT_byte_size, &sz, DW_ATTR_REQ);
957	tdp->t_size = sz;
958
959	/*
960	 * GCC allows empty SOUs as an extension.
961	 */
962	if ((mem = die_child(dw, str)) == NULL) {
963		goto out;
964	}
965
966	mlastp = &tdp->t_members;
967
968	do {
969		Dwarf_Off memoff = die_off(dw, mem);
970		Dwarf_Half tag = die_tag(dw, mem);
971		Dwarf_Unsigned mloff;
972
973		if (tag != DW_TAG_member) {
974			/* Nested type declaration */
975			die_create_one(dw, mem);
976			continue;
977		}
978
979		debug(3, "die %llu: mem %llu: creating member\n", off, memoff);
980
981		ml = xcalloc(sizeof (mlist_t));
982
983		/*
984		 * This could be a GCC anon struct/union member, so we'll allow
985		 * an empty name, even though nothing can really handle them
986		 * properly.  Note that some versions of GCC miss out debug
987		 * info for anon structs, though recent versions are fixed (gcc
988		 * bug 11816).
989		 */
990		if ((ml->ml_name = die_name(dw, mem)) == NULL)
991			ml->ml_name = NULL;
992
993		ml->ml_type = die_lookup_pass1(dw, mem, DW_AT_type);
994
995		if (die_mem_offset(dw, mem, DW_AT_data_member_location,
996		    &mloff, 0)) {
997			debug(3, "die %llu: got mloff %llx\n", off,
998			    (u_longlong_t)mloff);
999			ml->ml_offset = mloff * 8;
1000		}
1001
1002		if (die_unsigned(dw, mem, DW_AT_bit_size, &bitsz, 0))
1003			ml->ml_size = bitsz;
1004		else
1005			ml->ml_size = tdesc_bitsize(ml->ml_type);
1006
1007		if (die_unsigned(dw, mem, DW_AT_bit_offset, &bitoff, 0)) {
1008#if BYTE_ORDER == _BIG_ENDIAN
1009			ml->ml_offset += bitoff;
1010#else
1011			/*
1012			 * Note that Clang 3.4 will sometimes generate
1013			 * member DIE before generating the DIE for the
1014			 * member's type. The code can not handle this
1015			 * properly so that tdesc_bitsize(ml->ml_type) will
1016			 * return 0 because ml->ml_type is unknown. As a
1017			 * result, a wrong member offset will be calculated.
1018			 * To workaround this, we can instead try to
1019			 * retrieve the value of DW_AT_byte_size attribute
1020			 * which stores the byte size of the space occupied
1021			 * by the type. If this attribute exists, its value
1022			 * should equal to tdesc_bitsize(ml->ml_type)/NBBY.
1023			 */
1024			if (die_unsigned(dw, mem, DW_AT_byte_size, &bysz, 0) &&
1025			    bysz > 0)
1026				ml->ml_offset += bysz * NBBY - bitoff -
1027				    ml->ml_size;
1028			else
1029				ml->ml_offset += tdesc_bitsize(ml->ml_type) -
1030				    bitoff - ml->ml_size;
1031#endif
1032		}
1033
1034		debug(3, "die %llu: mem %llu: created \"%s\" (off %u sz %u)\n",
1035		    off, memoff, ml->ml_name, ml->ml_offset, ml->ml_size);
1036
1037		*mlastp = ml;
1038		mlastp = &ml->ml_next;
1039	} while ((mem = die_sibling(dw, mem)) != NULL);
1040
1041	/*
1042	 * GCC will attempt to eliminate unused types, thus decreasing the
1043	 * size of the emitted dwarf.  That is, if you declare a foo_t in your
1044	 * header, include said header in your source file, and neglect to
1045	 * actually use (directly or indirectly) the foo_t in the source file,
1046	 * the foo_t won't make it into the emitted DWARF.  So, at least, goes
1047	 * the theory.
1048	 *
1049	 * Occasionally, it'll emit the DW_TAG_structure_type for the foo_t,
1050	 * and then neglect to emit the members.  Strangely, the loner struct
1051	 * tag will always be followed by a proper nested declaration of
1052	 * something else.  This is clearly a bug, but we're not going to have
1053	 * time to get it fixed before this goo goes back, so we'll have to work
1054	 * around it.  If we see a no-membered struct with a nested declaration
1055	 * (i.e. die_child of the struct tag won't be null), we'll ignore it.
1056	 * Being paranoid, we won't simply remove it from the hash.  Instead,
1057	 * we'll decline to create an iidesc for it, thus ensuring that this
1058	 * type won't make it into the output file.  To be safe, we'll also
1059	 * change the name.
1060	 */
1061	if (tdp->t_members == NULL) {
1062		const char *old = tdesc_name(tdp);
1063		size_t newsz = 7 + strlen(old) + 1;
1064		char *new = xmalloc(newsz);
1065		(void) snprintf(new, newsz, "orphan %s", old);
1066
1067		debug(3, "die %llu: worked around %s %s\n", off, typename, old);
1068
1069		if (tdp->t_name != NULL)
1070			free(tdp->t_name);
1071		tdp->t_name = new;
1072		return;
1073	}
1074
1075out:
1076	if (tdp->t_name != NULL) {
1077		ii = xcalloc(sizeof (iidesc_t));
1078		ii->ii_type = II_SOU;
1079		ii->ii_name = xstrdup(tdp->t_name);
1080		ii->ii_dtype = tdp;
1081
1082		iidesc_add(dw->dw_td->td_iihash, ii);
1083	}
1084}
1085
1086static void
1087die_struct_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1088{
1089	die_sou_create(dw, die, off, tdp, STRUCT, "struct");
1090}
1091
1092static void
1093die_union_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1094{
1095	die_sou_create(dw, die, off, tdp, UNION, "union");
1096}
1097
1098/*ARGSUSED1*/
1099static int
1100die_sou_resolve(tdesc_t *tdp, tdesc_t **tdpp __unused, void *private)
1101{
1102	dwarf_t *dw = private;
1103	mlist_t *ml;
1104	tdesc_t *mt;
1105
1106	if (tdp->t_flags & TDESC_F_RESOLVED)
1107		return (1);
1108
1109	debug(3, "resolving sou %s\n", tdesc_name(tdp));
1110
1111	for (ml = tdp->t_members; ml != NULL; ml = ml->ml_next) {
1112		if (ml->ml_size == 0) {
1113			mt = tdesc_basetype(ml->ml_type);
1114
1115			if ((ml->ml_size = tdesc_bitsize(mt)) != 0)
1116				continue;
1117
1118			/*
1119			 * For empty members, or GCC/C99 flexible array
1120			 * members, a size of 0 is correct. Structs and unions
1121			 * consisting of flexible array members will also have
1122			 * size 0.
1123			 */
1124			if (mt->t_members == NULL)
1125				continue;
1126			if (mt->t_type == ARRAY && mt->t_ardef->ad_nelems == 0)
1127				continue;
1128			if ((mt->t_flags & TDESC_F_RESOLVED) != 0 &&
1129			    (mt->t_type == STRUCT || mt->t_type == UNION))
1130				continue;
1131
1132			dw->dw_nunres++;
1133			return (1);
1134		}
1135
1136		if ((mt = tdesc_basetype(ml->ml_type)) == NULL) {
1137			dw->dw_nunres++;
1138			return (1);
1139		}
1140
1141		if (ml->ml_size != 0 && mt->t_type == INTRINSIC &&
1142		    mt->t_intr->intr_nbits != ml->ml_size) {
1143			/*
1144			 * This member is a bitfield, and needs to reference
1145			 * an intrinsic type with the same width.  If the
1146			 * currently-referenced type isn't of the same width,
1147			 * we'll copy it, adjusting the width of the copy to
1148			 * the size we'd like.
1149			 */
1150			debug(3, "tdp %u: creating bitfield for %d bits\n",
1151			    tdp->t_id, ml->ml_size);
1152
1153			ml->ml_type = tdesc_intr_clone(dw, mt, ml->ml_size);
1154		}
1155	}
1156
1157	tdp->t_flags |= TDESC_F_RESOLVED;
1158
1159	return (1);
1160}
1161
1162/*ARGSUSED1*/
1163static int
1164die_sou_failed(tdesc_t *tdp, tdesc_t **tdpp __unused, void *private __unused)
1165{
1166	const char *typename = (tdp->t_type == STRUCT ? "struct" : "union");
1167	mlist_t *ml;
1168
1169	if (tdp->t_flags & TDESC_F_RESOLVED)
1170		return (1);
1171
1172	for (ml = tdp->t_members; ml != NULL; ml = ml->ml_next) {
1173		if (ml->ml_size == 0) {
1174			fprintf(stderr, "%s %d <%x>: failed to size member \"%s\" "
1175			    "of type %s (%d <%x>)\n", typename, tdp->t_id,
1176			    tdp->t_id,
1177			    ml->ml_name, tdesc_name(ml->ml_type),
1178			    ml->ml_type->t_id, ml->ml_type->t_id);
1179		}
1180	}
1181
1182	return (1);
1183}
1184
1185static void
1186die_funcptr_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1187{
1188	Dwarf_Attribute attr;
1189	Dwarf_Half tag;
1190	Dwarf_Die arg;
1191	fndef_t *fn;
1192	int i;
1193
1194	debug(3, "die %llu <%llx>: creating function pointer\n", off, off);
1195
1196	/*
1197	 * We'll begin by processing any type definition nodes that may be
1198	 * lurking underneath this one.
1199	 */
1200	for (arg = die_child(dw, die); arg != NULL;
1201	    arg = die_sibling(dw, arg)) {
1202		if ((tag = die_tag(dw, arg)) != DW_TAG_formal_parameter &&
1203		    tag != DW_TAG_unspecified_parameters) {
1204			/* Nested type declaration */
1205			die_create_one(dw, arg);
1206		}
1207	}
1208
1209	if (die_isdecl(dw, die)) {
1210		/*
1211		 * This is a prototype.  We don't add prototypes to the
1212		 * tree, so we're going to drop the tdesc.  Unfortunately,
1213		 * it has already been added to the tree.  Nobody will reference
1214		 * it, though, and it will be leaked.
1215		 */
1216		return;
1217	}
1218
1219	fn = xcalloc(sizeof (fndef_t));
1220
1221	tdp->t_type = FUNCTION;
1222
1223	if ((attr = die_attr(dw, die, DW_AT_type, 0)) != NULL) {
1224		fn->fn_ret = die_lookup_pass1(dw, die, DW_AT_type);
1225	} else {
1226		fn->fn_ret = tdesc_intr_void(dw);
1227	}
1228
1229	/*
1230	 * Count the arguments to the function, then read them in.
1231	 */
1232	for (fn->fn_nargs = 0, arg = die_child(dw, die); arg != NULL;
1233	    arg = die_sibling(dw, arg)) {
1234		if ((tag = die_tag(dw, arg)) == DW_TAG_formal_parameter)
1235			fn->fn_nargs++;
1236		else if (tag == DW_TAG_unspecified_parameters &&
1237		    fn->fn_nargs > 0)
1238			fn->fn_vargs = 1;
1239	}
1240
1241	if (fn->fn_nargs != 0) {
1242		debug(3, "die %llu: adding %d argument%s\n", off, fn->fn_nargs,
1243		    (fn->fn_nargs > 1 ? "s" : ""));
1244
1245		fn->fn_args = xcalloc(sizeof (tdesc_t *) * fn->fn_nargs);
1246		for (i = 0, arg = die_child(dw, die);
1247		    arg != NULL && i < (int) fn->fn_nargs;
1248		    arg = die_sibling(dw, arg)) {
1249			if (die_tag(dw, arg) != DW_TAG_formal_parameter)
1250				continue;
1251
1252			fn->fn_args[i++] = die_lookup_pass1(dw, arg,
1253			    DW_AT_type);
1254		}
1255	}
1256
1257	tdp->t_fndef = fn;
1258	tdp->t_flags |= TDESC_F_RESOLVED;
1259}
1260
1261/*
1262 * GCC and DevPro use different names for the base types.  While the terms are
1263 * the same, they are arranged in a different order.  Some terms, such as int,
1264 * are implied in one, and explicitly named in the other.  Given a base type
1265 * as input, this routine will return a common name, along with an intr_t
1266 * that reflects said name.
1267 */
1268static intr_t *
1269die_base_name_parse(const char *name, char **newp)
1270{
1271	char buf[256];
1272	char const *base;
1273	char *c;
1274	int nlong = 0, nshort = 0, nchar = 0, nint = 0;
1275	int sign = 1;
1276	char fmt = '\0';
1277	intr_t *intr;
1278
1279	if (strlen(name) > sizeof (buf) - 1)
1280		terminate("base type name \"%s\" is too long\n", name);
1281
1282	strncpy(buf, name, sizeof (buf));
1283
1284	for (c = strtok(buf, " "); c != NULL; c = strtok(NULL, " ")) {
1285		if (strcmp(c, "signed") == 0)
1286			sign = 1;
1287		else if (strcmp(c, "unsigned") == 0)
1288			sign = 0;
1289		else if (strcmp(c, "long") == 0)
1290			nlong++;
1291		else if (strcmp(c, "char") == 0) {
1292			nchar++;
1293			fmt = 'c';
1294		} else if (strcmp(c, "short") == 0)
1295			nshort++;
1296		else if (strcmp(c, "int") == 0)
1297			nint++;
1298		else {
1299			/*
1300			 * If we don't recognize any of the tokens, we'll tell
1301			 * the caller to fall back to the dwarf-provided
1302			 * encoding information.
1303			 */
1304			return (NULL);
1305		}
1306	}
1307
1308	if (nchar > 1 || nshort > 1 || nint > 1 || nlong > 2)
1309		return (NULL);
1310
1311	if (nchar > 0) {
1312		if (nlong > 0 || nshort > 0 || nint > 0)
1313			return (NULL);
1314
1315		base = "char";
1316
1317	} else if (nshort > 0) {
1318		if (nlong > 0)
1319			return (NULL);
1320
1321		base = "short";
1322
1323	} else if (nlong > 0) {
1324		base = "long";
1325
1326	} else {
1327		base = "int";
1328	}
1329
1330	intr = xcalloc(sizeof (intr_t));
1331	intr->intr_type = INTR_INT;
1332	intr->intr_signed = sign;
1333	intr->intr_iformat = fmt;
1334
1335	snprintf(buf, sizeof (buf), "%s%s%s",
1336	    (sign ? "" : "unsigned "),
1337	    (nlong > 1 ? "long " : ""),
1338	    base);
1339
1340	*newp = xstrdup(buf);
1341	return (intr);
1342}
1343
1344typedef struct fp_size_map {
1345	size_t fsm_typesz[2];	/* size of {32,64} type */
1346	uint_t fsm_enc[3];	/* CTF_FP_* for {bare,cplx,imagry} type */
1347} fp_size_map_t;
1348
1349static const fp_size_map_t fp_encodings[] = {
1350	{ { 4, 4 }, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } },
1351	{ { 8, 8 }, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } },
1352#ifdef __sparc
1353	{ { 16, 16 }, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } },
1354#else
1355	{ { 12, 16 }, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } },
1356#endif
1357	{ { 0, 0 }, { 0, 0, 0 } }
1358};
1359
1360static uint_t
1361die_base_type2enc(dwarf_t *dw, Dwarf_Off off, Dwarf_Signed enc, size_t sz)
1362{
1363	const fp_size_map_t *map = fp_encodings;
1364	uint_t szidx = dw->dw_ptrsz == sizeof (uint64_t);
1365	uint_t mult = 1, col = 0;
1366
1367	if (enc == DW_ATE_complex_float) {
1368		mult = 2;
1369		col = 1;
1370	} else if (enc == DW_ATE_imaginary_float
1371#ifdef illumos
1372	    || enc == DW_ATE_SUN_imaginary_float
1373#endif
1374	    )
1375		col = 2;
1376
1377	while (map->fsm_typesz[szidx] != 0) {
1378		if (map->fsm_typesz[szidx] * mult == sz)
1379			return (map->fsm_enc[col]);
1380		map++;
1381	}
1382
1383	terminate("die %llu: unrecognized real type size %u\n", off, sz);
1384	/*NOTREACHED*/
1385	return (0);
1386}
1387
1388static intr_t *
1389die_base_from_dwarf(dwarf_t *dw, Dwarf_Die base, Dwarf_Off off, size_t sz)
1390{
1391	intr_t *intr = xcalloc(sizeof (intr_t));
1392	Dwarf_Signed enc;
1393
1394	(void) die_signed(dw, base, DW_AT_encoding, &enc, DW_ATTR_REQ);
1395
1396	switch (enc) {
1397	case DW_ATE_unsigned:
1398	case DW_ATE_address:
1399		intr->intr_type = INTR_INT;
1400		break;
1401	case DW_ATE_unsigned_char:
1402		intr->intr_type = INTR_INT;
1403		intr->intr_iformat = 'c';
1404		break;
1405	case DW_ATE_signed:
1406		intr->intr_type = INTR_INT;
1407		intr->intr_signed = 1;
1408		break;
1409	case DW_ATE_signed_char:
1410		intr->intr_type = INTR_INT;
1411		intr->intr_signed = 1;
1412		intr->intr_iformat = 'c';
1413		break;
1414	case DW_ATE_boolean:
1415		intr->intr_type = INTR_INT;
1416		intr->intr_signed = 1;
1417		intr->intr_iformat = 'b';
1418		break;
1419	case DW_ATE_float:
1420	case DW_ATE_complex_float:
1421	case DW_ATE_imaginary_float:
1422#ifdef illumos
1423	case DW_ATE_SUN_imaginary_float:
1424	case DW_ATE_SUN_interval_float:
1425#endif
1426		intr->intr_type = INTR_REAL;
1427		intr->intr_signed = 1;
1428		intr->intr_fformat = die_base_type2enc(dw, off, enc, sz);
1429		break;
1430	default:
1431		terminate("die %llu: unknown base type encoding 0x%llx\n",
1432		    off, enc);
1433	}
1434
1435	return (intr);
1436}
1437
1438static void
1439die_base_create(dwarf_t *dw, Dwarf_Die base, Dwarf_Off off, tdesc_t *tdp)
1440{
1441	Dwarf_Unsigned sz;
1442	intr_t *intr;
1443	char *new;
1444
1445	debug(3, "die %llu: creating base type\n", off);
1446
1447	/*
1448	 * The compilers have their own clever (internally inconsistent) ideas
1449	 * as to what base types should look like.  Some times gcc will, for
1450	 * example, use DW_ATE_signed_char for char.  Other times, however, it
1451	 * will use DW_ATE_signed.  Needless to say, this causes some problems
1452	 * down the road, particularly with merging.  We do, however, use the
1453	 * DWARF idea of type sizes, as this allows us to avoid caring about
1454	 * the data model.
1455	 */
1456	(void) die_unsigned(dw, base, DW_AT_byte_size, &sz, DW_ATTR_REQ);
1457
1458	if (tdp->t_name == NULL)
1459		terminate("die %llu: base type without name\n", off);
1460
1461	/* XXX make a name parser for float too */
1462	if ((intr = die_base_name_parse(tdp->t_name, &new)) != NULL) {
1463		/* Found it.  We'll use the parsed version */
1464		debug(3, "die %llu: name \"%s\" remapped to \"%s\"\n", off,
1465		    tdesc_name(tdp), new);
1466
1467		free(tdp->t_name);
1468		tdp->t_name = new;
1469	} else {
1470		/*
1471		 * We didn't recognize the type, so we'll create an intr_t
1472		 * based on the DWARF data.
1473		 */
1474		debug(3, "die %llu: using dwarf data for base \"%s\"\n", off,
1475		    tdesc_name(tdp));
1476
1477		intr = die_base_from_dwarf(dw, base, off, sz);
1478	}
1479
1480	intr->intr_nbits = sz * 8;
1481
1482	tdp->t_type = INTRINSIC;
1483	tdp->t_intr = intr;
1484	tdp->t_size = sz;
1485
1486	tdp->t_flags |= TDESC_F_RESOLVED;
1487}
1488
1489static void
1490die_through_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp,
1491    int type, const char *typename)
1492{
1493	Dwarf_Attribute attr;
1494
1495	debug(3, "die %llu <%llx>: creating %s type %d\n", off, off, typename, type);
1496
1497	tdp->t_type = type;
1498
1499	if ((attr = die_attr(dw, die, DW_AT_type, 0)) != NULL) {
1500		tdp->t_tdesc = die_lookup_pass1(dw, die, DW_AT_type);
1501	} else {
1502		tdp->t_tdesc = tdesc_intr_void(dw);
1503	}
1504
1505	if (type == POINTER)
1506		tdp->t_size = dw->dw_ptrsz;
1507
1508	tdp->t_flags |= TDESC_F_RESOLVED;
1509
1510	if (type == TYPEDEF) {
1511		iidesc_t *ii = xcalloc(sizeof (iidesc_t));
1512		ii->ii_type = II_TYPE;
1513		ii->ii_name = xstrdup(tdp->t_name);
1514		ii->ii_dtype = tdp;
1515
1516		iidesc_add(dw->dw_td->td_iihash, ii);
1517	}
1518}
1519
1520static void
1521die_typedef_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1522{
1523	die_through_create(dw, die, off, tdp, TYPEDEF, "typedef");
1524}
1525
1526static void
1527die_const_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1528{
1529	die_through_create(dw, die, off, tdp, CONST, "const");
1530}
1531
1532static void
1533die_pointer_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1534{
1535	die_through_create(dw, die, off, tdp, POINTER, "pointer");
1536}
1537
1538static void
1539die_restrict_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1540{
1541	die_through_create(dw, die, off, tdp, RESTRICT, "restrict");
1542}
1543
1544static void
1545die_volatile_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1546{
1547	die_through_create(dw, die, off, tdp, VOLATILE, "volatile");
1548}
1549
1550/*ARGSUSED3*/
1551static void
1552die_function_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp __unused)
1553{
1554	Dwarf_Die arg;
1555	Dwarf_Half tag;
1556	iidesc_t *ii;
1557	char *name;
1558
1559	debug(3, "die %llu <%llx>: creating function definition\n", off, off);
1560
1561	/*
1562	 * We'll begin by processing any type definition nodes that may be
1563	 * lurking underneath this one.
1564	 */
1565	for (arg = die_child(dw, die); arg != NULL;
1566	    arg = die_sibling(dw, arg)) {
1567		if ((tag = die_tag(dw, arg)) != DW_TAG_formal_parameter &&
1568		    tag != DW_TAG_variable) {
1569			/* Nested type declaration */
1570			die_create_one(dw, arg);
1571		}
1572	}
1573
1574	if (die_isdecl(dw, die) || (name = die_name(dw, die)) == NULL) {
1575		/*
1576		 * We process neither prototypes nor subprograms without
1577		 * names.
1578		 */
1579		return;
1580	}
1581
1582	ii = xcalloc(sizeof (iidesc_t));
1583	ii->ii_type = die_isglobal(dw, die) ? II_GFUN : II_SFUN;
1584	ii->ii_name = name;
1585	if (ii->ii_type == II_SFUN)
1586		ii->ii_owner = xstrdup(dw->dw_cuname);
1587
1588	debug(3, "die %llu: function %s is %s\n", off, ii->ii_name,
1589	    (ii->ii_type == II_GFUN ? "global" : "static"));
1590
1591	if (die_attr(dw, die, DW_AT_type, 0) != NULL)
1592		ii->ii_dtype = die_lookup_pass1(dw, die, DW_AT_type);
1593	else
1594		ii->ii_dtype = tdesc_intr_void(dw);
1595
1596	for (arg = die_child(dw, die); arg != NULL;
1597	    arg = die_sibling(dw, arg)) {
1598		char *name1;
1599
1600		debug(3, "die %llu: looking at sub member at %llu\n",
1601		    off, die_off(dw, die));
1602
1603		if (die_tag(dw, arg) != DW_TAG_formal_parameter)
1604			continue;
1605
1606		if ((name1 = die_name(dw, arg)) == NULL) {
1607			terminate("die %llu: func arg %d has no name\n",
1608			    off, ii->ii_nargs + 1);
1609		}
1610
1611		if (strcmp(name1, "...") == 0) {
1612			free(name1);
1613			ii->ii_vargs = 1;
1614			continue;
1615		}
1616		free(name1);
1617
1618		ii->ii_nargs++;
1619	}
1620
1621	if (ii->ii_nargs > 0) {
1622		int i;
1623
1624		debug(3, "die %llu: function has %d argument%s\n", off,
1625		    ii->ii_nargs, (ii->ii_nargs == 1 ? "" : "s"));
1626
1627		ii->ii_args = xcalloc(sizeof (tdesc_t) * ii->ii_nargs);
1628
1629		for (arg = die_child(dw, die), i = 0;
1630		    arg != NULL && i < ii->ii_nargs;
1631		    arg = die_sibling(dw, arg)) {
1632			if (die_tag(dw, arg) != DW_TAG_formal_parameter)
1633				continue;
1634
1635			ii->ii_args[i++] = die_lookup_pass1(dw, arg,
1636			    DW_AT_type);
1637		}
1638	}
1639
1640	iidesc_add(dw->dw_td->td_iihash, ii);
1641}
1642
1643/*ARGSUSED3*/
1644static void
1645die_variable_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp __unused)
1646{
1647	iidesc_t *ii;
1648	char *name;
1649
1650	debug(3, "die %llu: creating object definition\n", off);
1651
1652	if (die_isdecl(dw, die) || (name = die_name(dw, die)) == NULL)
1653		return; /* skip prototypes and nameless objects */
1654
1655	ii = xcalloc(sizeof (iidesc_t));
1656	ii->ii_type = die_isglobal(dw, die) ? II_GVAR : II_SVAR;
1657	ii->ii_name = name;
1658	ii->ii_dtype = die_lookup_pass1(dw, die, DW_AT_type);
1659	if (ii->ii_type == II_SVAR)
1660		ii->ii_owner = xstrdup(dw->dw_cuname);
1661
1662	iidesc_add(dw->dw_td->td_iihash, ii);
1663}
1664
1665/*ARGSUSED2*/
1666static int
1667die_fwd_resolve(tdesc_t *fwd, tdesc_t **fwdp, void *private __unused)
1668{
1669	if (fwd->t_flags & TDESC_F_RESOLVED)
1670		return (1);
1671
1672	if (fwd->t_tdesc != NULL) {
1673		debug(3, "tdp %u: unforwarded %s\n", fwd->t_id,
1674		    tdesc_name(fwd));
1675		*fwdp = fwd->t_tdesc;
1676	}
1677
1678	fwd->t_flags |= TDESC_F_RESOLVED;
1679
1680	return (1);
1681}
1682
1683/*ARGSUSED*/
1684static void
1685die_lexblk_descend(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off __unused, tdesc_t *tdp __unused)
1686{
1687	Dwarf_Die child = die_child(dw, die);
1688
1689	if (child != NULL)
1690		die_create(dw, child);
1691}
1692
1693/*
1694 * Used to map the die to a routine which can parse it, using the tag to do the
1695 * mapping.  While the processing of most tags entails the creation of a tdesc,
1696 * there are a few which don't - primarily those which result in the creation of
1697 * iidescs which refer to existing tdescs.
1698 */
1699
1700#define	DW_F_NOTDP	0x1	/* Don't create a tdesc for the creator */
1701
1702typedef struct die_creator {
1703	Dwarf_Half dc_tag;
1704	uint16_t dc_flags;
1705	void (*dc_create)(dwarf_t *, Dwarf_Die, Dwarf_Off, tdesc_t *);
1706} die_creator_t;
1707
1708static const die_creator_t die_creators[] = {
1709	{ DW_TAG_array_type,		0,		die_array_create },
1710	{ DW_TAG_enumeration_type,	0,		die_enum_create },
1711	{ DW_TAG_lexical_block,		DW_F_NOTDP,	die_lexblk_descend },
1712	{ DW_TAG_pointer_type,		0,		die_pointer_create },
1713	{ DW_TAG_structure_type,	0,		die_struct_create },
1714	{ DW_TAG_subroutine_type,	0,		die_funcptr_create },
1715	{ DW_TAG_typedef,		0,		die_typedef_create },
1716	{ DW_TAG_union_type,		0,		die_union_create },
1717	{ DW_TAG_base_type,		0,		die_base_create },
1718	{ DW_TAG_const_type,		0,		die_const_create },
1719	{ DW_TAG_subprogram,		DW_F_NOTDP,	die_function_create },
1720	{ DW_TAG_variable,		DW_F_NOTDP,	die_variable_create },
1721	{ DW_TAG_volatile_type,		0,		die_volatile_create },
1722	{ DW_TAG_restrict_type,		0,		die_restrict_create },
1723	{ 0, 0, NULL }
1724};
1725
1726static const die_creator_t *
1727die_tag2ctor(Dwarf_Half tag)
1728{
1729	const die_creator_t *dc;
1730
1731	for (dc = die_creators; dc->dc_create != NULL; dc++) {
1732		if (dc->dc_tag == tag)
1733			return (dc);
1734	}
1735
1736	return (NULL);
1737}
1738
1739static void
1740die_create_one(dwarf_t *dw, Dwarf_Die die)
1741{
1742	Dwarf_Off off = die_off(dw, die);
1743	const die_creator_t *dc;
1744	Dwarf_Half tag;
1745	tdesc_t *tdp;
1746
1747	debug(3, "die %llu <%llx>: create_one\n", off, off);
1748
1749	if (off > dw->dw_maxoff) {
1750		terminate("illegal die offset %llu (max %llu)\n", off,
1751		    dw->dw_maxoff);
1752	}
1753
1754	tag = die_tag(dw, die);
1755
1756	if ((dc = die_tag2ctor(tag)) == NULL) {
1757		debug(2, "die %llu: ignoring tag type %x\n", off, tag);
1758		return;
1759	}
1760
1761	if ((tdp = tdesc_lookup(dw, off)) == NULL &&
1762	    !(dc->dc_flags & DW_F_NOTDP)) {
1763		tdp = xcalloc(sizeof (tdesc_t));
1764		tdp->t_id = off;
1765		tdesc_add(dw, tdp);
1766	}
1767
1768	if (tdp != NULL)
1769		tdp->t_name = die_name(dw, die);
1770
1771	dc->dc_create(dw, die, off, tdp);
1772}
1773
1774static void
1775die_create(dwarf_t *dw, Dwarf_Die die)
1776{
1777	do {
1778		die_create_one(dw, die);
1779	} while ((die = die_sibling(dw, die)) != NULL);
1780}
1781
1782static tdtrav_cb_f die_resolvers[] = {
1783	NULL,
1784	NULL,			/* intrinsic */
1785	NULL,			/* pointer */
1786	die_array_resolve,	/* array */
1787	NULL,			/* function */
1788	die_sou_resolve,	/* struct */
1789	die_sou_resolve,	/* union */
1790	die_enum_resolve,	/* enum */
1791	die_fwd_resolve,	/* forward */
1792	NULL,			/* typedef */
1793	NULL,			/* typedef unres */
1794	NULL,			/* volatile */
1795	NULL,			/* const */
1796	NULL,			/* restrict */
1797};
1798
1799static tdtrav_cb_f die_fail_reporters[] = {
1800	NULL,
1801	NULL,			/* intrinsic */
1802	NULL,			/* pointer */
1803	die_array_failed,	/* array */
1804	NULL,			/* function */
1805	die_sou_failed,		/* struct */
1806	die_sou_failed,		/* union */
1807	NULL,			/* enum */
1808	NULL,			/* forward */
1809	NULL,			/* typedef */
1810	NULL,			/* typedef unres */
1811	NULL,			/* volatile */
1812	NULL,			/* const */
1813	NULL,			/* restrict */
1814};
1815
1816static void
1817die_resolve(dwarf_t *dw)
1818{
1819	int last = -1;
1820	int pass = 0;
1821
1822	do {
1823		pass++;
1824		dw->dw_nunres = 0;
1825
1826		(void) iitraverse_hash(dw->dw_td->td_iihash,
1827		    &dw->dw_td->td_curvgen, NULL, NULL, die_resolvers, dw);
1828
1829		debug(3, "resolve: pass %d, %u left\n", pass, dw->dw_nunres);
1830
1831		if ((int) dw->dw_nunres == last) {
1832			fprintf(stderr, "%s: failed to resolve the following "
1833			    "types:\n", progname);
1834
1835			(void) iitraverse_hash(dw->dw_td->td_iihash,
1836			    &dw->dw_td->td_curvgen, NULL, NULL,
1837			    die_fail_reporters, dw);
1838
1839			terminate("failed to resolve types\n");
1840		}
1841
1842		last = dw->dw_nunres;
1843
1844	} while (dw->dw_nunres != 0);
1845}
1846
1847/*
1848 * Any object containing a function or object symbol at any scope should also
1849 * contain DWARF data.
1850 */
1851static boolean_t
1852should_have_dwarf(Elf *elf)
1853{
1854	Elf_Scn *scn = NULL;
1855	Elf_Data *data = NULL;
1856	GElf_Shdr shdr;
1857	GElf_Sym sym;
1858	uint32_t symdx = 0;
1859	size_t nsyms = 0;
1860	boolean_t found = B_FALSE;
1861
1862	while ((scn = elf_nextscn(elf, scn)) != NULL) {
1863		gelf_getshdr(scn, &shdr);
1864
1865		if (shdr.sh_type == SHT_SYMTAB) {
1866			found = B_TRUE;
1867			break;
1868		}
1869	}
1870
1871	if (!found)
1872		terminate("cannot convert stripped objects\n");
1873
1874	data = elf_getdata(scn, NULL);
1875	nsyms = shdr.sh_size / shdr.sh_entsize;
1876
1877	for (symdx = 0; symdx < nsyms; symdx++) {
1878		gelf_getsym(data, symdx, &sym);
1879
1880		if ((GELF_ST_TYPE(sym.st_info) == STT_FUNC) ||
1881		    (GELF_ST_TYPE(sym.st_info) == STT_TLS) ||
1882		    (GELF_ST_TYPE(sym.st_info) == STT_OBJECT)) {
1883			char *name;
1884
1885			name = elf_strptr(elf, shdr.sh_link, sym.st_name);
1886
1887			/* Studio emits these local symbols regardless */
1888			if ((strcmp(name, "Bbss.bss") != 0) &&
1889			    (strcmp(name, "Ttbss.bss") != 0) &&
1890			    (strcmp(name, "Ddata.data") != 0) &&
1891			    (strcmp(name, "Ttdata.data") != 0) &&
1892			    (strcmp(name, "Drodata.rodata") != 0))
1893				return (B_TRUE);
1894		}
1895	}
1896
1897	return (B_FALSE);
1898}
1899
1900/*ARGSUSED*/
1901int
1902dw_read(tdata_t *td, Elf *elf, char *filename __unused)
1903{
1904	Dwarf_Unsigned abboff, hdrlen, lang, nxthdr;
1905	Dwarf_Half vers, addrsz, offsz;
1906	Dwarf_Die cu = 0;
1907	Dwarf_Die child = 0;
1908	dwarf_t dw;
1909	char *prod = NULL;
1910	int rc;
1911
1912	bzero(&dw, sizeof (dwarf_t));
1913	dw.dw_td = td;
1914	dw.dw_ptrsz = elf_ptrsz(elf);
1915	dw.dw_mfgtid_last = TID_MFGTID_BASE;
1916	dw.dw_tidhash = hash_new(TDESC_HASH_BUCKETS, tdesc_idhash, tdesc_idcmp);
1917	dw.dw_fwdhash = hash_new(TDESC_HASH_BUCKETS, tdesc_namehash,
1918	    tdesc_namecmp);
1919	dw.dw_enumhash = hash_new(TDESC_HASH_BUCKETS, tdesc_namehash,
1920	    tdesc_namecmp);
1921
1922	if ((rc = dwarf_elf_init(elf, DW_DLC_READ, NULL, NULL, &dw.dw_dw,
1923	    &dw.dw_err)) == DW_DLV_NO_ENTRY) {
1924		if (should_have_dwarf(elf)) {
1925			errno = ENOENT;
1926			return (-1);
1927		} else {
1928			return (0);
1929		}
1930	} else if (rc != DW_DLV_OK) {
1931		if (dwarf_errno(dw.dw_err) == DW_DLE_DEBUG_INFO_NULL) {
1932			/*
1933			 * There's no type data in the DWARF section, but
1934			 * libdwarf is too clever to handle that properly.
1935			 */
1936			return (0);
1937		}
1938
1939		terminate("failed to initialize DWARF: %s\n",
1940		    dwarf_errmsg(dw.dw_err));
1941	}
1942
1943	if ((rc = dwarf_next_cu_header_b(dw.dw_dw, &hdrlen, &vers, &abboff,
1944	    &addrsz, &offsz, NULL, &nxthdr, &dw.dw_err)) != DW_DLV_OK) {
1945		if (dw.dw_err.err_error == DW_DLE_NO_ENTRY)
1946			exit(0);
1947		else
1948			terminate("rc = %d %s\n", rc, dwarf_errmsg(dw.dw_err));
1949	}
1950	if ((cu = die_sibling(&dw, NULL)) == NULL ||
1951	    (((child = die_child(&dw, cu)) == NULL) &&
1952	    should_have_dwarf(elf))) {
1953		terminate("file does not contain dwarf type data "
1954		    "(try compiling with -g)\n");
1955	} else if (child == NULL) {
1956		return (0);
1957	}
1958
1959	dw.dw_maxoff = nxthdr - 1;
1960
1961	if (dw.dw_maxoff > TID_FILEMAX)
1962		terminate("file contains too many types\n");
1963
1964	debug(1, "DWARF version: %d\n", vers);
1965	if (vers < 2 || vers > 4) {
1966		terminate("file contains incompatible version %d DWARF code "
1967		    "(version 2, 3 or 4 required)\n", vers);
1968	}
1969
1970	if (die_string(&dw, cu, DW_AT_producer, &prod, 0)) {
1971		debug(1, "DWARF emitter: %s\n", prod);
1972		free(prod);
1973	}
1974
1975	if (dwarf_attrval_unsigned(cu, DW_AT_language, &lang, &dw.dw_err) == 0)
1976		switch (lang) {
1977		case DW_LANG_C:
1978		case DW_LANG_C89:
1979		case DW_LANG_C99:
1980		case DW_LANG_C11:
1981		case DW_LANG_C_plus_plus:
1982		case DW_LANG_C_plus_plus_03:
1983		case DW_LANG_C_plus_plus_11:
1984		case DW_LANG_C_plus_plus_14:
1985		case DW_LANG_Mips_Assembler:
1986			break;
1987		default:
1988			terminate("file contains DWARF for unsupported "
1989			    "language %#x", lang);
1990		}
1991	else
1992		warning("die %llu: failed to get language attribute: %s\n",
1993		    die_off(&dw, cu), dwarf_errmsg(dw.dw_err));
1994
1995	if ((dw.dw_cuname = die_name(&dw, cu)) != NULL) {
1996		char *base = xstrdup(basename(dw.dw_cuname));
1997		free(dw.dw_cuname);
1998		dw.dw_cuname = base;
1999
2000		debug(1, "CU name: %s\n", dw.dw_cuname);
2001	}
2002
2003	if ((child = die_child(&dw, cu)) != NULL)
2004		die_create(&dw, child);
2005
2006	if ((rc = dwarf_next_cu_header_b(dw.dw_dw, &hdrlen, &vers, &abboff,
2007	    &addrsz, &offsz, NULL, &nxthdr, &dw.dw_err)) != DW_DLV_NO_ENTRY)
2008		terminate("multiple compilation units not supported\n");
2009
2010	(void) dwarf_finish(dw.dw_dw, &dw.dw_err);
2011
2012	die_resolve(&dw);
2013
2014	cvt_fixups(td, dw.dw_ptrsz);
2015
2016	/* leak the dwarf_t */
2017
2018	return (0);
2019}
2020