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 * Copyright 2012 Jason King.  All rights reserved.
27 * Use is subject to license terms.
28 */
29
30/*
31 * Copyright 2019, Joyent, Inc.
32 */
33
34/*
35 * CTF DWARF conversion theory.
36 *
37 * DWARF data contains a series of compilation units. Each compilation unit
38 * generally refers to an object file or what once was, in the case of linked
39 * binaries and shared objects. Each compilation unit has a series of what DWARF
40 * calls a DIE (Debugging Information Entry). The set of entries that we care
41 * about have type information stored in a series of attributes. Each DIE also
42 * has a tag that identifies the kind of attributes that it has.
43 *
44 * A given DIE may itself have children. For example, a DIE that represents a
45 * structure has children which represent members. Whenever we encounter a DIE
46 * that has children or other values or types associated with it, we recursively
47 * process those children first so that way we can then refer to the generated
48 * CTF type id while processing its parent. This reduces the amount of unknowns
49 * and fixups that we need. It also ensures that we don't accidentally add types
50 * that an overzealous compiler might add to the DWARF data but aren't used by
51 * anything in the system.
52 *
53 * Once we do a conversion, we store a mapping in an AVL tree that goes from the
54 * DWARF's die offset, which is relative to the given compilation unit, to a
55 * ctf_id_t.
56 *
57 * Unfortunately, some compilers actually will emit duplicate entries for a
58 * given type that look similar, but aren't quite. To that end, we go through
59 * and do a variant on a merge once we're done processing a single compilation
60 * unit which deduplicates all of the types that are in the unit.
61 *
62 * Finally, if we encounter an object that has multiple compilation units, then
63 * we'll convert all of the compilation units separately and then do a merge, so
64 * that way we can result in one single ctf_file_t that represents everything
65 * for the object.
66 *
67 * Conversion Steps
68 * ----------------
69 *
70 * Because a given object we've been given to convert may have multiple
71 * compilation units, we break the work into two halves. The first half
72 * processes each compilation unit (potentially in parallel) and then the second
73 * half optionally merges all of the dies in the first half. First, we'll cover
74 * what's involved in converting a single ctf_cu_t's dwarf to CTF. This covers
75 * the work done in ctf_dwarf_convert_one().
76 *
77 * An individual ctf_cu_t, which represents a compilation unit, is converted to
78 * CTF in a series of multiple passes.
79 *
80 * Pass 1: During the first pass we walk all of the top-level dies and if we
81 * find a function, variable, struct, union, enum or typedef, we recursively
82 * transform all of its types. We don't recurse or process everything, because
83 * we don't want to add some of the types that compilers may add which are
84 * effectively unused.
85 *
86 * During pass 1, if we encounter any structures or unions we mark them for
87 * fixing up later. This is necessary because we may not be able to determine
88 * the full size of a structure at the beginning of time. This will happen if
89 * the DWARF attribute DW_AT_byte_size is not present for a member. Because of
90 * this possibility we defer adding members to structures or even converting
91 * them during pass 1 and save that for pass 2. Adding all of the base
92 * structures without any of their members helps deal with any circular
93 * dependencies that we might encounter.
94 *
95 * Pass 2: This pass is used to do the first half of fixing up structures and
96 * unions. Rather than walk the entire type space again, we actually walk the
97 * list of structures and unions that we marked for later fixing up. Here, we
98 * iterate over every structure and add members to the underlying ctf_file_t,
99 * but not to the structs themselves. One might wonder why we don't, and the
100 * main reason is that libctf requires a ctf_update() be done before adding the
101 * members to structures or unions.
102 *
103 * Pass 3: This pass is used to do the second half of fixing up structures and
104 * unions. During this part we always go through and add members to structures
105 * and unions that we added to the container in the previous pass. In addition,
106 * we set the structure and union's actual size, which may have additional
107 * padding added by the compiler, it isn't simply the last offset. DWARF always
108 * guarantees an attribute exists for this. Importantly no ctf_id_t's change
109 * during pass 2.
110 *
111 * Pass 4: The next phase is to add CTF entries for all of the symbols and
112 * variables that are present in this die. During pass 1 we added entries to a
113 * map for each variable and function. During this pass, we iterate over the
114 * symbol table and when we encounter a symbol that we have in our lists of
115 * translated information which matches, we then add it to the ctf_file_t.
116 *
117 * Pass 5: Here we go and look for any weak symbols and functions and see if
118 * they match anything that we recognize. If so, then we add type information
119 * for them at this point based on the matching type.
120 *
121 * Pass 6: This pass is actually a variant on a merge. The traditional merge
122 * process expects there to be no duplicate types. As such, at the end of
123 * conversion, we do a dedup on all of the types in the system. The
124 * deduplication process is described in lib/libctf/common/ctf_merge.c.
125 *
126 * Once pass 6 is done, we've finished processing the individual compilation
127 * unit.
128 *
129 * The following steps reflect the general process of doing a conversion.
130 *
131 * 1) Walk the dwarf section and determine the number of compilation units
132 * 2) Create a ctf_cu_t for each compilation unit
133 * 3) Add all ctf_cu_t's to a workq
134 * 4) Have the workq process each die with ctf_dwarf_convert_one. This itself
135 *    is comprised of several steps, which were already enumerated.
136 * 5) If we have multiple cu's, we do a ctf merge of all the dies. The mechanics
137 *    of the merge are discussed in lib/libctf/common/ctf_merge.c.
138 * 6) Free everything up and return a ctf_file_t to the user. If we only had a
139 *    single compilation unit, then we give that to the user. Otherwise, we
140 *    return the merged ctf_file_t.
141 *
142 * Threading
143 * ---------
144 *
145 * The process has been designed to be amenable to threading. Each compilation
146 * unit has its own type stream, therefore the logical place to divide and
147 * conquer is at the compilation unit. Each ctf_cu_t has been built to be able
148 * to be processed independently of the others. It has its own libdwarf handle,
149 * as a given libdwarf handle may only be used by a single thread at a time.
150 * This allows the various ctf_cu_t's to be processed in parallel by different
151 * threads.
152 *
153 * All of the ctf_cu_t's are loaded into a workq which allows for a number of
154 * threads to be specified and used as a thread pool to process all of the
155 * queued work. We set the number of threads to use in the workq equal to the
156 * number of threads that the user has specified.
157 *
158 * After all of the compilation units have been drained, we use the same number
159 * of threads when performing a merge of multiple compilation units, if they
160 * exist.
161 *
162 * While all of these different parts do support and allow for multiple threads,
163 * it's important that when only a single thread is specified, that it be the
164 * calling thread. This allows the conversion routines to be used in a context
165 * that doesn't allow additional threads, such as rtld.
166 *
167 * Common DWARF Mechanics and Notes
168 * --------------------------------
169 *
170 * At this time, we really only support DWARFv2, though support for DWARFv4 is
171 * mostly there. There is no intent to support DWARFv3.
172 *
173 * Generally types for something are stored in the DW_AT_type attribute. For
174 * example, a function's return type will be stored in the local DW_AT_type
175 * attribute while the arguments will be in child DIEs. There are also various
176 * times when we don't have any DW_AT_type. In that case, the lack of a type
177 * implies, at least for C, that its C type is void. Because DWARF doesn't emit
178 * one, we have a synthetic void type that we create and manipulate instead and
179 * pass it off to consumers on an as-needed basis. If nothing has a void type,
180 * it will not be emitted.
181 *
182 * Architecture Specific Parts
183 * ---------------------------
184 *
185 * The CTF tooling encodes various information about the various architectures
186 * in the system. Importantly, the tool assumes that every architecture has a
187 * data model where long and pointer are the same size. This is currently the
188 * case, as the two data models illumos supports are ILP32 and LP64.
189 *
190 * In addition, we encode the mapping of various floating point sizes to various
191 * types for each architecture. If a new architecture is being added, it should
192 * be added to the list. The general design of the ctf conversion tools is to be
193 * architecture independent. eg. any of the tools here should be able to convert
194 * any architecture's DWARF into ctf; however, this has not been rigorously
195 * tested and more importantly, the ctf routines don't currently write out the
196 * data in an endian-aware form, they only use that of the currently running
197 * library.
198 */
199
200#include <libctf_impl.h>
201#include <sys/avl.h>
202#include <sys/debug.h>
203#include <gelf.h>
204#include <libdwarf.h>
205#include <dwarf.h>
206#include <libgen.h>
207#include <workq.h>
208#include <errno.h>
209
210#define	DWARF_VERSION_TWO	2
211#define	DWARF_VARARGS_NAME	"..."
212
213/*
214 * Dwarf may refer recursively to other types that we've already processed. To
215 * see if we've already converted them, we look them up in an AVL tree that's
216 * sorted by the DWARF id.
217 */
218typedef struct ctf_dwmap {
219	avl_node_t	cdm_avl;
220	Dwarf_Off	cdm_off;
221	Dwarf_Die	cdm_die;
222	ctf_id_t	cdm_id;
223	boolean_t	cdm_fix;
224} ctf_dwmap_t;
225
226typedef struct ctf_dwvar {
227	ctf_list_t	cdv_list;
228	char		*cdv_name;
229	ctf_id_t	cdv_type;
230	boolean_t	cdv_global;
231} ctf_dwvar_t;
232
233typedef struct ctf_dwfunc {
234	ctf_list_t	cdf_list;
235	char		*cdf_name;
236	ctf_funcinfo_t	cdf_fip;
237	ctf_id_t	*cdf_argv;
238	boolean_t	cdf_global;
239} ctf_dwfunc_t;
240
241typedef struct ctf_dwbitf {
242	ctf_list_t	cdb_list;
243	ctf_id_t	cdb_base;
244	uint_t		cdb_nbits;
245	ctf_id_t	cdb_id;
246} ctf_dwbitf_t;
247
248/*
249 * The ctf_cu_t represents a single top-level DWARF die unit. While generally,
250 * the typical object file has only a single die, if we're asked to convert
251 * something that's been linked from multiple sources, multiple dies will exist.
252 */
253typedef struct ctf_die {
254	Elf		*cu_elf;	/* shared libelf handle */
255	char		*cu_name;	/* basename of the DIE */
256	ctf_merge_t	*cu_cmh;	/* merge handle */
257	ctf_list_t	cu_vars;	/* List of variables */
258	ctf_list_t	cu_funcs;	/* List of functions */
259	ctf_list_t	cu_bitfields;	/* Bit field members */
260	Dwarf_Debug	cu_dwarf;	/* libdwarf handle */
261	Dwarf_Die	cu_cu;		/* libdwarf compilation unit */
262	Dwarf_Off	cu_cuoff;	/* cu's offset */
263	Dwarf_Off	cu_maxoff;	/* maximum offset */
264	ctf_file_t	*cu_ctfp;	/* output CTF file */
265	avl_tree_t	cu_map;		/* map die offsets to CTF types */
266	char		*cu_errbuf;	/* error message buffer */
267	size_t		cu_errlen;	/* error message buffer length */
268	size_t		cu_ptrsz;	/* object's pointer size */
269	boolean_t	cu_bigend;	/* is it big endian */
270	boolean_t	cu_doweaks;	/* should we convert weak symbols? */
271	uint_t		cu_mach;	/* machine type */
272	ctf_id_t	cu_voidtid;	/* void pointer */
273	ctf_id_t	cu_longtid;	/* id for a 'long' */
274} ctf_cu_t;
275
276static int ctf_dwarf_offset(ctf_cu_t *, Dwarf_Die, Dwarf_Off *);
277static int ctf_dwarf_convert_die(ctf_cu_t *, Dwarf_Die);
278static int ctf_dwarf_convert_type(ctf_cu_t *, Dwarf_Die, ctf_id_t *, int);
279
280static int ctf_dwarf_function_count(ctf_cu_t *, Dwarf_Die, ctf_funcinfo_t *,
281    boolean_t);
282static int ctf_dwarf_convert_fargs(ctf_cu_t *, Dwarf_Die, ctf_funcinfo_t *,
283    ctf_id_t *);
284
285/*
286 * This is a generic way to set a CTF Conversion backend error depending on what
287 * we were doing. Unless it was one of a specific set of errors that don't
288 * indicate a programming / translation bug, eg. ENOMEM, then we transform it
289 * into a CTF backend error and fill in the error buffer.
290 */
291static int
292ctf_dwarf_error(ctf_cu_t *cup, ctf_file_t *cfp, int err, const char *fmt, ...)
293{
294	va_list ap;
295	int ret;
296	size_t off = 0;
297	ssize_t rem = cup->cu_errlen;
298	if (cfp != NULL)
299		err = ctf_errno(cfp);
300
301	if (err == ENOMEM)
302		return (err);
303
304	ret = snprintf(cup->cu_errbuf, rem, "die %s: ", cup->cu_name);
305	if (ret < 0)
306		goto err;
307	off += ret;
308	rem = MAX(rem - ret, 0);
309
310	va_start(ap, fmt);
311	ret = vsnprintf(cup->cu_errbuf + off, rem, fmt, ap);
312	va_end(ap);
313	if (ret < 0)
314		goto err;
315
316	off += ret;
317	rem = MAX(rem - ret, 0);
318	if (fmt[strlen(fmt) - 1] != '\n') {
319		(void) snprintf(cup->cu_errbuf + off, rem,
320		    ": %s\n", ctf_errmsg(err));
321	}
322	va_end(ap);
323	return (ECTF_CONVBKERR);
324
325err:
326	cup->cu_errbuf[0] = '\0';
327	return (ECTF_CONVBKERR);
328}
329
330/*
331 * DWARF often opts to put no explicit type to describe a void type. eg. if we
332 * have a reference type whose DW_AT_type member doesn't exist, then we should
333 * instead assume it points to void. Because this isn't represented, we
334 * instead cause it to come into existence.
335 */
336static ctf_id_t
337ctf_dwarf_void(ctf_cu_t *cup)
338{
339	if (cup->cu_voidtid == CTF_ERR) {
340		ctf_encoding_t enc = { CTF_INT_SIGNED, 0, 0 };
341		cup->cu_voidtid = ctf_add_integer(cup->cu_ctfp, CTF_ADD_ROOT,
342		    "void", &enc);
343		if (cup->cu_voidtid == CTF_ERR) {
344			(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
345			    "failed to create void type: %s\n",
346			    ctf_errmsg(ctf_errno(cup->cu_ctfp)));
347		}
348	}
349
350	return (cup->cu_voidtid);
351}
352
353/*
354 * There are many different forms that an array index may take. However, we just
355 * always force it to be of a type long no matter what. Therefore we use this to
356 * have a single instance of long across everything.
357 */
358static ctf_id_t
359ctf_dwarf_long(ctf_cu_t *cup)
360{
361	if (cup->cu_longtid == CTF_ERR) {
362		ctf_encoding_t enc;
363
364		enc.cte_format = CTF_INT_SIGNED;
365		enc.cte_offset = 0;
366		/* All illumos systems are LP */
367		enc.cte_bits = cup->cu_ptrsz * 8;
368		cup->cu_longtid = ctf_add_integer(cup->cu_ctfp, CTF_ADD_NONROOT,
369		    "long", &enc);
370		if (cup->cu_longtid == CTF_ERR) {
371			(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
372			    "failed to create long type: %s\n",
373			    ctf_errmsg(ctf_errno(cup->cu_ctfp)));
374		}
375
376	}
377
378	return (cup->cu_longtid);
379}
380
381static int
382ctf_dwmap_comp(const void *a, const void *b)
383{
384	const ctf_dwmap_t *ca = a;
385	const ctf_dwmap_t *cb = b;
386
387	if (ca->cdm_off > cb->cdm_off)
388		return (1);
389	if (ca->cdm_off < cb->cdm_off)
390		return (-1);
391	return (0);
392}
393
394static int
395ctf_dwmap_add(ctf_cu_t *cup, ctf_id_t id, Dwarf_Die die, boolean_t fix)
396{
397	int ret;
398	avl_index_t index;
399	ctf_dwmap_t *dwmap;
400	Dwarf_Off off;
401
402	VERIFY(id > 0 && id < CTF_MAX_TYPE);
403
404	if ((ret = ctf_dwarf_offset(cup, die, &off)) != 0)
405		return (ret);
406
407	if ((dwmap = ctf_alloc(sizeof (ctf_dwmap_t))) == NULL)
408		return (ENOMEM);
409
410	dwmap->cdm_die = die;
411	dwmap->cdm_off = off;
412	dwmap->cdm_id = id;
413	dwmap->cdm_fix = fix;
414
415	ctf_dprintf("dwmap: %p %" DW_PR_DUx "->%d\n", dwmap, off, id);
416	VERIFY(avl_find(&cup->cu_map, dwmap, &index) == NULL);
417	avl_insert(&cup->cu_map, dwmap, index);
418	return (0);
419}
420
421static int
422ctf_dwarf_attribute(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name,
423    Dwarf_Attribute *attrp)
424{
425	int ret;
426	Dwarf_Error derr;
427
428	if ((ret = dwarf_attr(die, name, attrp, &derr)) == DW_DLV_OK)
429		return (0);
430	if (ret == DW_DLV_NO_ENTRY) {
431		*attrp = NULL;
432		return (ENOENT);
433	}
434	(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
435	    "failed to get attribute for type: %s\n",
436	    dwarf_errmsg(derr));
437	return (ECTF_CONVBKERR);
438}
439
440static int
441ctf_dwarf_ref(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, Dwarf_Off *refp)
442{
443	int ret;
444	Dwarf_Attribute attr;
445	Dwarf_Error derr;
446
447	if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0)
448		return (ret);
449
450	if (dwarf_formref(attr, refp, &derr) == DW_DLV_OK) {
451		dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR);
452		return (0);
453	}
454
455	(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
456	    "failed to get unsigned attribute for type: %s\n",
457	    dwarf_errmsg(derr));
458	return (ECTF_CONVBKERR);
459}
460
461static int
462ctf_dwarf_refdie(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name,
463    Dwarf_Die *diep)
464{
465	int ret;
466	Dwarf_Off off;
467	Dwarf_Error derr;
468
469	if ((ret = ctf_dwarf_ref(cup, die, name, &off)) != 0)
470		return (ret);
471
472	off += cup->cu_cuoff;
473	if ((ret = dwarf_offdie(cup->cu_dwarf, off, diep, &derr)) !=
474	    DW_DLV_OK) {
475		(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
476		    "failed to get die from offset %" DW_PR_DUu ": %s\n",
477		    off, dwarf_errmsg(derr));
478		return (ECTF_CONVBKERR);
479	}
480
481	return (0);
482}
483
484static int
485ctf_dwarf_signed(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name,
486    Dwarf_Signed *valp)
487{
488	int ret;
489	Dwarf_Attribute attr;
490	Dwarf_Error derr;
491
492	if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0)
493		return (ret);
494
495	if (dwarf_formsdata(attr, valp, &derr) == DW_DLV_OK) {
496		dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR);
497		return (0);
498	}
499
500	(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
501	    "failed to get unsigned attribute for type: %s\n",
502	    dwarf_errmsg(derr));
503	return (ECTF_CONVBKERR);
504}
505
506static int
507ctf_dwarf_unsigned(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name,
508    Dwarf_Unsigned *valp)
509{
510	int ret;
511	Dwarf_Attribute attr;
512	Dwarf_Error derr;
513
514	if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0)
515		return (ret);
516
517	if (dwarf_formudata(attr, valp, &derr) == DW_DLV_OK) {
518		dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR);
519		return (0);
520	}
521
522	(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
523	    "failed to get unsigned attribute for type: %s\n",
524	    dwarf_errmsg(derr));
525	return (ECTF_CONVBKERR);
526}
527
528static int
529ctf_dwarf_boolean(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name,
530    Dwarf_Bool *val)
531{
532	int ret;
533	Dwarf_Attribute attr;
534	Dwarf_Error derr;
535
536	if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0)
537		return (ret);
538
539	if (dwarf_formflag(attr, val, &derr) == DW_DLV_OK) {
540		dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR);
541		return (0);
542	}
543
544	(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
545	    "failed to get boolean attribute for type: %s\n",
546	    dwarf_errmsg(derr));
547
548	return (ECTF_CONVBKERR);
549}
550
551static int
552ctf_dwarf_string(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, char **strp)
553{
554	int ret;
555	char *s;
556	Dwarf_Attribute attr;
557	Dwarf_Error derr;
558
559	*strp = NULL;
560	if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0)
561		return (ret);
562
563	if (dwarf_formstring(attr, &s, &derr) == DW_DLV_OK) {
564		if ((*strp = ctf_strdup(s)) == NULL)
565			ret = ENOMEM;
566		else
567			ret = 0;
568		dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR);
569		return (ret);
570	}
571
572	(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
573	    "failed to get string attribute for type: %s\n",
574	    dwarf_errmsg(derr));
575	return (ECTF_CONVBKERR);
576}
577
578static int
579ctf_dwarf_member_location(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Unsigned *valp)
580{
581	int ret;
582	Dwarf_Error derr;
583	Dwarf_Attribute attr;
584	Dwarf_Locdesc *loc;
585	Dwarf_Signed locnum;
586
587	if ((ret = ctf_dwarf_attribute(cup, die, DW_AT_data_member_location,
588	    &attr)) != 0)
589		return (ret);
590
591	if (dwarf_loclist(attr, &loc, &locnum, &derr) != DW_DLV_OK) {
592		(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
593		    "failed to obtain location list for member offset: %s",
594		    dwarf_errmsg(derr));
595		dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR);
596		return (ECTF_CONVBKERR);
597	}
598	dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR);
599
600	if (locnum != 1 || loc->ld_s->lr_atom != DW_OP_plus_uconst) {
601		(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
602		    "failed to parse location structure for member");
603		dwarf_dealloc(cup->cu_dwarf, loc->ld_s, DW_DLA_LOC_BLOCK);
604		dwarf_dealloc(cup->cu_dwarf, loc, DW_DLA_LOCDESC);
605		return (ECTF_CONVBKERR);
606	}
607
608	*valp = loc->ld_s->lr_number;
609
610	dwarf_dealloc(cup->cu_dwarf, loc->ld_s, DW_DLA_LOC_BLOCK);
611	dwarf_dealloc(cup->cu_dwarf, loc, DW_DLA_LOCDESC);
612	return (0);
613}
614
615
616static int
617ctf_dwarf_offset(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Off *offsetp)
618{
619	Dwarf_Error derr;
620
621	if (dwarf_dieoffset(die, offsetp, &derr) == DW_DLV_OK)
622		return (0);
623
624	(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
625	    "failed to get die offset: %s\n",
626	    dwarf_errmsg(derr));
627	return (ECTF_CONVBKERR);
628}
629
630/* simpler variant for debugging output */
631static Dwarf_Off
632ctf_die_offset(Dwarf_Die die)
633{
634	Dwarf_Off off = -1;
635	Dwarf_Error derr;
636
637	(void) dwarf_dieoffset(die, &off, &derr);
638	return (off);
639}
640
641static int
642ctf_dwarf_tag(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half *tagp)
643{
644	Dwarf_Error derr;
645
646	if (dwarf_tag(die, tagp, &derr) == DW_DLV_OK)
647		return (0);
648
649	(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
650	    "failed to get tag type: %s\n",
651	    dwarf_errmsg(derr));
652	return (ECTF_CONVBKERR);
653}
654
655static int
656ctf_dwarf_sib(ctf_cu_t *cup, Dwarf_Die base, Dwarf_Die *sibp)
657{
658	Dwarf_Error derr;
659	int ret;
660
661	*sibp = NULL;
662	ret = dwarf_siblingof(cup->cu_dwarf, base, sibp, &derr);
663	if (ret == DW_DLV_OK || ret == DW_DLV_NO_ENTRY)
664		return (0);
665
666	(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
667	    "failed to sibling from die: %s\n",
668	    dwarf_errmsg(derr));
669	return (ECTF_CONVBKERR);
670}
671
672static int
673ctf_dwarf_child(ctf_cu_t *cup, Dwarf_Die base, Dwarf_Die *childp)
674{
675	Dwarf_Error derr;
676	int ret;
677
678	*childp = NULL;
679	ret = dwarf_child(base, childp, &derr);
680	if (ret == DW_DLV_OK || ret == DW_DLV_NO_ENTRY)
681		return (0);
682
683	(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
684	    "failed to child from die: %s\n",
685	    dwarf_errmsg(derr));
686	return (ECTF_CONVBKERR);
687}
688
689/*
690 * Compilers disagree on what to do to determine if something has global
691 * visiblity. Traditionally gcc has used DW_AT_external to indicate this while
692 * Studio has used DW_AT_visibility. We check DW_AT_visibility first and then
693 * fall back to DW_AT_external. Lack of DW_AT_external implies that it is not.
694 */
695static int
696ctf_dwarf_isglobal(ctf_cu_t *cup, Dwarf_Die die, boolean_t *igp)
697{
698	int ret;
699	Dwarf_Signed vis;
700	Dwarf_Bool ext;
701
702	if ((ret = ctf_dwarf_signed(cup, die, DW_AT_visibility, &vis)) == 0) {
703		*igp = vis == DW_VIS_exported;
704		return (0);
705	} else if (ret != ENOENT) {
706		return (ret);
707	}
708
709	if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_external, &ext)) != 0) {
710		if (ret == ENOENT) {
711			*igp = B_FALSE;
712			return (0);
713		}
714		return (ret);
715	}
716	*igp = ext != 0 ? B_TRUE : B_FALSE;
717	return (0);
718}
719
720static int
721ctf_dwarf_die_elfenc(Elf *elf, ctf_cu_t *cup, char *errbuf, size_t errlen)
722{
723	GElf_Ehdr ehdr;
724
725	if (gelf_getehdr(elf, &ehdr) == NULL) {
726		(void) snprintf(errbuf, errlen,
727		    "failed to get ELF header: %s\n",
728		    elf_errmsg(elf_errno()));
729		return (ECTF_CONVBKERR);
730	}
731
732	cup->cu_mach = ehdr.e_machine;
733
734	if (ehdr.e_ident[EI_CLASS] == ELFCLASS32) {
735		cup->cu_ptrsz = 4;
736		VERIFY(ctf_setmodel(cup->cu_ctfp, CTF_MODEL_ILP32) == 0);
737	} else if (ehdr.e_ident[EI_CLASS] == ELFCLASS64) {
738		cup->cu_ptrsz = 8;
739		VERIFY(ctf_setmodel(cup->cu_ctfp, CTF_MODEL_LP64) == 0);
740	} else {
741		(void) snprintf(errbuf, errlen,
742		    "unknown ELF class %d", ehdr.e_ident[EI_CLASS]);
743		return (ECTF_CONVBKERR);
744	}
745
746	if (ehdr.e_ident[EI_DATA] == ELFDATA2LSB) {
747		cup->cu_bigend = B_FALSE;
748	} else if (ehdr.e_ident[EI_DATA] == ELFDATA2MSB) {
749		cup->cu_bigend = B_TRUE;
750	} else {
751		(void) snprintf(errbuf, errlen,
752		    "unknown ELF data encoding: %hhu", ehdr.e_ident[EI_DATA]);
753		return (ECTF_CONVBKERR);
754	}
755
756	return (0);
757}
758
759typedef struct ctf_dwarf_fpent {
760	size_t	cdfe_size;
761	uint_t	cdfe_enc[3];
762} ctf_dwarf_fpent_t;
763
764typedef struct ctf_dwarf_fpmap {
765	uint_t			cdf_mach;
766	ctf_dwarf_fpent_t	cdf_ents[4];
767} ctf_dwarf_fpmap_t;
768
769static const ctf_dwarf_fpmap_t ctf_dwarf_fpmaps[] = {
770	{ EM_SPARC, {
771		{ 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } },
772		{ 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } },
773		{ 16, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } },
774		{ 0, { 0 } }
775	} },
776	{ EM_SPARC32PLUS, {
777		{ 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } },
778		{ 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } },
779		{ 16, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } },
780		{ 0, { 0 } }
781	} },
782	{ EM_SPARCV9, {
783		{ 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } },
784		{ 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } },
785		{ 16, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } },
786		{ 0, { 0 } }
787	} },
788	{ EM_386, {
789		{ 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } },
790		{ 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } },
791		{ 12, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } },
792		{ 0, { 0 } }
793	} },
794	{ EM_X86_64, {
795		{ 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } },
796		{ 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } },
797		{ 16, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } },
798		{ 0, { 0 } }
799	} },
800	{ EM_NONE }
801};
802
803static int
804ctf_dwarf_float_base(ctf_cu_t *cup, Dwarf_Signed type, ctf_encoding_t *enc)
805{
806	const ctf_dwarf_fpmap_t *map = &ctf_dwarf_fpmaps[0];
807	const ctf_dwarf_fpent_t *ent;
808	uint_t col = 0, mult = 1;
809
810	for (map = &ctf_dwarf_fpmaps[0]; map->cdf_mach != EM_NONE; map++) {
811		if (map->cdf_mach == cup->cu_mach)
812			break;
813	}
814
815	if (map->cdf_mach == EM_NONE) {
816		(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
817		    "Unsupported machine type: %d\n", cup->cu_mach);
818		return (ENOTSUP);
819	}
820
821	if (type == DW_ATE_complex_float) {
822		mult = 2;
823		col = 1;
824	} else if (type == DW_ATE_imaginary_float ||
825	    type == DW_ATE_SUN_imaginary_float) {
826		col = 2;
827	}
828
829	ent = &map->cdf_ents[0];
830	for (ent = &map->cdf_ents[0]; ent->cdfe_size != 0; ent++) {
831		if (ent->cdfe_size * mult * 8 == enc->cte_bits) {
832			enc->cte_format = ent->cdfe_enc[col];
833			return (0);
834		}
835	}
836
837	(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
838	    "failed to find valid fp mapping for encoding %d, size %d bits\n",
839	    type, enc->cte_bits);
840	return (EINVAL);
841}
842
843static int
844ctf_dwarf_dwarf_base(ctf_cu_t *cup, Dwarf_Die die, int *kindp,
845    ctf_encoding_t *enc)
846{
847	int ret;
848	Dwarf_Signed type;
849
850	if ((ret = ctf_dwarf_signed(cup, die, DW_AT_encoding, &type)) != 0)
851		return (ret);
852
853	switch (type) {
854	case DW_ATE_unsigned:
855	case DW_ATE_address:
856		*kindp = CTF_K_INTEGER;
857		enc->cte_format = 0;
858		break;
859	case DW_ATE_unsigned_char:
860		*kindp = CTF_K_INTEGER;
861		enc->cte_format = CTF_INT_CHAR;
862		break;
863	case DW_ATE_signed:
864		*kindp = CTF_K_INTEGER;
865		enc->cte_format = CTF_INT_SIGNED;
866		break;
867	case DW_ATE_signed_char:
868		*kindp = CTF_K_INTEGER;
869		enc->cte_format = CTF_INT_SIGNED | CTF_INT_CHAR;
870		break;
871	case DW_ATE_boolean:
872		*kindp = CTF_K_INTEGER;
873		enc->cte_format = CTF_INT_SIGNED | CTF_INT_BOOL;
874		break;
875	case DW_ATE_float:
876	case DW_ATE_complex_float:
877	case DW_ATE_imaginary_float:
878	case DW_ATE_SUN_imaginary_float:
879	case DW_ATE_SUN_interval_float:
880		*kindp = CTF_K_FLOAT;
881		if ((ret = ctf_dwarf_float_base(cup, type, enc)) != 0)
882			return (ret);
883		break;
884	default:
885		(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
886		    "encountered unknown DWARF encoding: %d", type);
887		return (ECTF_CONVBKERR);
888	}
889
890	return (0);
891}
892
893/*
894 * Different compilers (at least GCC and Studio) use different names for types.
895 * This parses the types and attempts to unify them. If this fails, we just fall
896 * back to using the DWARF itself.
897 */
898static int
899ctf_dwarf_parse_base(const char *name, int *kindp, ctf_encoding_t *enc,
900    char **newnamep)
901{
902	char buf[256];
903	char *base, *c, *last;
904	int nlong = 0, nshort = 0, nchar = 0, nint = 0;
905	int sign = 1;
906
907	if (strlen(name) + 1 > sizeof (buf))
908		return (EINVAL);
909
910	(void) strlcpy(buf, name, sizeof (buf));
911	for (c = strtok_r(buf, " ", &last); c != NULL;
912	    c = strtok_r(NULL, " ", &last)) {
913		if (strcmp(c, "signed") == 0) {
914			sign = 1;
915		} else if (strcmp(c, "unsigned") == 0) {
916			sign = 0;
917		} else if (strcmp(c, "long") == 0) {
918			nlong++;
919		} else if (strcmp(c, "char") == 0) {
920			nchar++;
921		} else if (strcmp(c, "short") == 0) {
922			nshort++;
923		} else if (strcmp(c, "int") == 0) {
924			nint++;
925		} else {
926			/*
927			 * If we don't recognize any of the tokens, we'll tell
928			 * the caller to fall back to the dwarf-provided
929			 * encoding information.
930			 */
931			return (EINVAL);
932		}
933	}
934
935	if (nchar > 1 || nshort > 1 || nint > 1 || nlong > 2)
936		return (EINVAL);
937
938	if (nchar > 0) {
939		if (nlong > 0 || nshort > 0 || nint > 0)
940			return (EINVAL);
941		base = "char";
942	} else if (nshort > 0) {
943		if (nlong > 0)
944			return (EINVAL);
945		base = "short";
946	} else if (nlong > 0) {
947		base = "long";
948	} else {
949		base = "int";
950	}
951
952	if (nchar > 0)
953		enc->cte_format = CTF_INT_CHAR;
954	else
955		enc->cte_format = 0;
956
957	if (sign > 0)
958		enc->cte_format |= CTF_INT_SIGNED;
959
960	(void) snprintf(buf, sizeof (buf), "%s%s%s",
961	    (sign ? "" : "unsigned "),
962	    (nlong > 1 ? "long " : ""),
963	    base);
964
965	*newnamep = ctf_strdup(buf);
966	if (*newnamep == NULL)
967		return (ENOMEM);
968	*kindp = CTF_K_INTEGER;
969	return (0);
970}
971
972static int
973ctf_dwarf_create_base(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, int isroot,
974    Dwarf_Off off)
975{
976	int ret;
977	char *name, *nname;
978	Dwarf_Unsigned sz;
979	int kind;
980	ctf_encoding_t enc;
981	ctf_id_t id;
982
983	if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0)
984		return (ret);
985	if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_byte_size, &sz)) != 0) {
986		goto out;
987	}
988	ctf_dprintf("Creating base type %s from off %llu, size: %d\n", name,
989	    off, sz);
990
991	bzero(&enc, sizeof (ctf_encoding_t));
992	enc.cte_bits = sz * 8;
993	if ((ret = ctf_dwarf_parse_base(name, &kind, &enc, &nname)) == 0) {
994		ctf_free(name, strlen(name) + 1);
995		name = nname;
996	} else {
997		if (ret != EINVAL)
998			return (ret);
999		ctf_dprintf("falling back to dwarf for base type %s\n", name);
1000		if ((ret = ctf_dwarf_dwarf_base(cup, die, &kind, &enc)) != 0)
1001			return (ret);
1002	}
1003
1004	id = ctf_add_encoded(cup->cu_ctfp, isroot, name, &enc, kind);
1005	if (id == CTF_ERR) {
1006		ret = ctf_errno(cup->cu_ctfp);
1007	} else {
1008		*idp = id;
1009		ret = ctf_dwmap_add(cup, id, die, B_FALSE);
1010	}
1011out:
1012	ctf_free(name, strlen(name) + 1);
1013	return (ret);
1014}
1015
1016/*
1017 * Getting a member's offset is a surprisingly intricate dance. It works as
1018 * follows:
1019 *
1020 * 1) If we're in DWARFv4, then we either have a DW_AT_data_bit_offset or we
1021 * have a DW_AT_data_member_location. We won't have both. Thus we check first
1022 * for DW_AT_data_bit_offset, and if it exists, we're set.
1023 *
1024 * Next, if we have a bitfield and we don't have a DW_AT_data_bit_offset, then
1025 * we have to grab the data location and use the following dance:
1026 *
1027 * 2) Gather the set of DW_AT_byte_size, DW_AT_bit_offset, and DW_AT_bit_size.
1028 * Of course, the DW_AT_byte_size may be omitted, even though it isn't always.
1029 * When it's been omitted, we then have to say that the size is that of the
1030 * underlying type, which forces that to be after a ctf_update(). Here, we have
1031 * to do different things based on whether or not we're using big endian or
1032 * little endian to obtain the proper offset.
1033 */
1034static int
1035ctf_dwarf_member_offset(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t mid,
1036    ulong_t *offp)
1037{
1038	int ret;
1039	Dwarf_Unsigned loc, bitsz, bytesz;
1040	Dwarf_Signed bitoff;
1041	size_t off;
1042	ssize_t tsz;
1043
1044	if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_data_bit_offset,
1045	    &loc)) == 0) {
1046		*offp = loc;
1047		return (0);
1048	} else if (ret != ENOENT) {
1049		return (ret);
1050	}
1051
1052	if ((ret = ctf_dwarf_member_location(cup, die, &loc)) != 0)
1053		return (ret);
1054	off = loc * 8;
1055
1056	if ((ret = ctf_dwarf_signed(cup, die, DW_AT_bit_offset,
1057	    &bitoff)) != 0) {
1058		if (ret != ENOENT)
1059			return (ret);
1060		*offp = off;
1061		return (0);
1062	}
1063
1064	/* At this point we have to have DW_AT_bit_size */
1065	if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_bit_size, &bitsz)) != 0)
1066		return (ret);
1067
1068	if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_byte_size,
1069	    &bytesz)) != 0) {
1070		if (ret != ENOENT)
1071			return (ret);
1072		if ((tsz = ctf_type_size(cup->cu_ctfp, mid)) == CTF_ERR) {
1073			int e = ctf_errno(cup->cu_ctfp);
1074			(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
1075			    "failed to get type size: %s", ctf_errmsg(e));
1076			return (ECTF_CONVBKERR);
1077		}
1078	} else {
1079		tsz = bytesz;
1080	}
1081	tsz *= 8;
1082	if (cup->cu_bigend == B_TRUE) {
1083		*offp = off + bitoff;
1084	} else {
1085		*offp = off + tsz - bitoff - bitsz;
1086	}
1087
1088	return (0);
1089}
1090
1091/*
1092 * We need to determine if the member in question is a bitfield. If it is, then
1093 * we need to go through and create a new type that's based on the actual base
1094 * type, but has a different size. We also rename the type as a result to help
1095 * deal with future collisions.
1096 *
1097 * Here we need to look and see if we have a DW_AT_bit_size value. If we have a
1098 * bit size member and it does not equal the byte size member, then we need to
1099 * create a bitfield type based on this.
1100 *
1101 * Note: When we support DWARFv4, there may be a chance that we need to also
1102 * search for the DW_AT_byte_size if we don't have a DW_AT_bit_size member.
1103 */
1104static int
1105ctf_dwarf_member_bitfield(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp)
1106{
1107	int ret;
1108	Dwarf_Unsigned bitsz;
1109	ctf_encoding_t e;
1110	ctf_dwbitf_t *cdb;
1111	ctf_dtdef_t *dtd;
1112	ctf_id_t base = *idp;
1113	int kind;
1114
1115	if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_bit_size, &bitsz)) != 0) {
1116		if (ret == ENOENT)
1117			return (0);
1118		return (ret);
1119	}
1120
1121	ctf_dprintf("Trying to deal with bitfields on %d:%d\n", base, bitsz);
1122	/*
1123	 * Given that we now have a bitsize, time to go do something about it.
1124	 * We're going to create a new type based on the current one, but first
1125	 * we need to find the base type. This means we need to traverse any
1126	 * typedef's, consts, and volatiles until we get to what should be
1127	 * something of type integer or enumeration.
1128	 */
1129	VERIFY(bitsz < UINT32_MAX);
1130	dtd = ctf_dtd_lookup(cup->cu_ctfp, base);
1131	VERIFY(dtd != NULL);
1132	kind = CTF_INFO_KIND(dtd->dtd_data.ctt_info);
1133	while (kind == CTF_K_TYPEDEF || kind == CTF_K_CONST ||
1134	    kind == CTF_K_VOLATILE) {
1135		dtd = ctf_dtd_lookup(cup->cu_ctfp, dtd->dtd_data.ctt_type);
1136		VERIFY(dtd != NULL);
1137		kind = CTF_INFO_KIND(dtd->dtd_data.ctt_info);
1138	}
1139	ctf_dprintf("got kind %d\n", kind);
1140	VERIFY(kind == CTF_K_INTEGER || kind == CTF_K_ENUM);
1141
1142	/*
1143	 * As surprising as it may be, it is strictly possible to create a
1144	 * bitfield that is based on an enum. Of course, the C standard leaves
1145	 * enums sizing as an ABI concern more or less. To that effect, today on
1146	 * all illumos platforms the size of an enum is generally that of an
1147	 * int as our supported data models and ABIs all agree on that. So what
1148	 * we'll do is fake up a CTF encoding here to use. In this case, we'll
1149	 * treat it as an unsigned value of whatever size the underlying enum
1150	 * currently has (which is in the ctt_size member of its dynamic type
1151	 * data).
1152	 */
1153	if (kind == CTF_K_INTEGER) {
1154		e = dtd->dtd_u.dtu_enc;
1155	} else {
1156		bzero(&e, sizeof (ctf_encoding_t));
1157		e.cte_bits = dtd->dtd_data.ctt_size * NBBY;
1158	}
1159
1160	for (cdb = ctf_list_next(&cup->cu_bitfields); cdb != NULL;
1161	    cdb = ctf_list_next(cdb)) {
1162		if (cdb->cdb_base == base && cdb->cdb_nbits == bitsz)
1163			break;
1164	}
1165
1166	/*
1167	 * Create a new type if none exists. We name all types in a way that is
1168	 * guaranteed not to conflict with the corresponding C type. We do this
1169	 * by using the ':' operator.
1170	 */
1171	if (cdb == NULL) {
1172		size_t namesz;
1173		char *name;
1174
1175		e.cte_bits = bitsz;
1176		namesz = snprintf(NULL, 0, "%s:%d", dtd->dtd_name,
1177		    (uint32_t)bitsz);
1178		name = ctf_alloc(namesz + 1);
1179		if (name == NULL)
1180			return (ENOMEM);
1181		cdb = ctf_alloc(sizeof (ctf_dwbitf_t));
1182		if (cdb == NULL) {
1183			ctf_free(name, namesz + 1);
1184			return (ENOMEM);
1185		}
1186		(void) snprintf(name, namesz + 1, "%s:%d", dtd->dtd_name,
1187		    (uint32_t)bitsz);
1188
1189		cdb->cdb_base = base;
1190		cdb->cdb_nbits = bitsz;
1191		cdb->cdb_id = ctf_add_integer(cup->cu_ctfp, CTF_ADD_NONROOT,
1192		    name, &e);
1193		if (cdb->cdb_id == CTF_ERR) {
1194			(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
1195			    "failed to get add bitfield type %s: %s", name,
1196			    ctf_errmsg(ctf_errno(cup->cu_ctfp)));
1197			ctf_free(name, namesz + 1);
1198			ctf_free(cdb, sizeof (ctf_dwbitf_t));
1199			return (ECTF_CONVBKERR);
1200		}
1201		ctf_free(name, namesz + 1);
1202		ctf_list_append(&cup->cu_bitfields, cdb);
1203	}
1204
1205	*idp = cdb->cdb_id;
1206
1207	return (0);
1208}
1209
1210static int
1211ctf_dwarf_fixup_sou(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t base, boolean_t add)
1212{
1213	int ret, kind;
1214	Dwarf_Die child, memb;
1215	Dwarf_Unsigned size;
1216	ulong_t nsz;
1217
1218	kind = ctf_type_kind(cup->cu_ctfp, base);
1219	VERIFY(kind != CTF_ERR);
1220	VERIFY(kind == CTF_K_STRUCT || kind == CTF_K_UNION);
1221
1222	/*
1223	 * Members are in children. However, gcc also allows empty ones.
1224	 */
1225	if ((ret = ctf_dwarf_child(cup, die, &child)) != 0)
1226		return (ret);
1227	if (child == NULL)
1228		return (0);
1229
1230	memb = child;
1231	while (memb != NULL) {
1232		Dwarf_Die sib, tdie;
1233		Dwarf_Half tag;
1234		ctf_id_t mid;
1235		char *mname;
1236		ulong_t memboff = 0;
1237
1238		if ((ret = ctf_dwarf_tag(cup, memb, &tag)) != 0)
1239			return (ret);
1240
1241		if (tag != DW_TAG_member)
1242			continue;
1243
1244		if ((ret = ctf_dwarf_refdie(cup, memb, DW_AT_type, &tdie)) != 0)
1245			return (ret);
1246
1247		if ((ret = ctf_dwarf_convert_type(cup, tdie, &mid,
1248		    CTF_ADD_NONROOT)) != 0)
1249			return (ret);
1250		ctf_dprintf("Got back type id: %d\n", mid);
1251
1252		/*
1253		 * If we're not adding a member, just go ahead and return.
1254		 */
1255		if (add == B_FALSE) {
1256			if ((ret = ctf_dwarf_member_bitfield(cup, memb,
1257			    &mid)) != 0)
1258				return (ret);
1259			goto next;
1260		}
1261
1262		if ((ret = ctf_dwarf_string(cup, memb, DW_AT_name,
1263		    &mname)) != 0 && ret != ENOENT)
1264			return (ret);
1265		if (ret == ENOENT)
1266			mname = NULL;
1267
1268		if (kind == CTF_K_UNION) {
1269			memboff = 0;
1270		} else if ((ret = ctf_dwarf_member_offset(cup, memb, mid,
1271		    &memboff)) != 0) {
1272			if (mname != NULL)
1273				ctf_free(mname, strlen(mname) + 1);
1274			return (ret);
1275		}
1276
1277		if ((ret = ctf_dwarf_member_bitfield(cup, memb, &mid)) != 0)
1278			return (ret);
1279
1280		ret = ctf_add_member(cup->cu_ctfp, base, mname, mid, memboff);
1281		if (ret == CTF_ERR) {
1282			(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
1283			    "failed to add member %s: %s",
1284			    mname, ctf_errmsg(ctf_errno(cup->cu_ctfp)));
1285			if (mname != NULL)
1286				ctf_free(mname, strlen(mname) + 1);
1287			return (ECTF_CONVBKERR);
1288		}
1289
1290		if (mname != NULL)
1291			ctf_free(mname, strlen(mname) + 1);
1292
1293next:
1294		if ((ret = ctf_dwarf_sib(cup, memb, &sib)) != 0)
1295			return (ret);
1296		memb = sib;
1297	}
1298
1299	/*
1300	 * If we're not adding members, then we don't know the final size of the
1301	 * structure, so end here.
1302	 */
1303	if (add == B_FALSE)
1304		return (0);
1305
1306	/* Finally set the size of the structure to the actual byte size */
1307	if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_byte_size, &size)) != 0)
1308		return (ret);
1309	nsz = size;
1310	if ((ctf_set_size(cup->cu_ctfp, base, nsz)) == CTF_ERR) {
1311		int e = ctf_errno(cup->cu_ctfp);
1312		(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
1313		    "failed to set type size for %d to 0x%x: %s", base,
1314		    (uint32_t)size, ctf_errmsg(e));
1315		return (ECTF_CONVBKERR);
1316	}
1317
1318	return (0);
1319}
1320
1321static int
1322ctf_dwarf_create_sou(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp,
1323    int kind, int isroot)
1324{
1325	int ret;
1326	char *name;
1327	ctf_id_t base;
1328	Dwarf_Die child;
1329	Dwarf_Bool decl;
1330
1331	/*
1332	 * Deal with the terribly annoying case of anonymous structs and unions.
1333	 * If they don't have a name, set the name to the empty string.
1334	 */
1335	if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0 &&
1336	    ret != ENOENT)
1337		return (ret);
1338	if (ret == ENOENT)
1339		name = NULL;
1340
1341	/*
1342	 * We need to check if we just have a declaration here. If we do, then
1343	 * instead of creating an actual structure or union, we're just going to
1344	 * go ahead and create a forward. During a dedup or merge, the forward
1345	 * will be replaced with the real thing.
1346	 */
1347	if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_declaration,
1348	    &decl)) != 0) {
1349		if (ret != ENOENT)
1350			return (ret);
1351		decl = 0;
1352	}
1353
1354	if (decl != 0) {
1355		base = ctf_add_forward(cup->cu_ctfp, isroot, name, kind);
1356	} else if (kind == CTF_K_STRUCT) {
1357		base = ctf_add_struct(cup->cu_ctfp, isroot, name);
1358	} else {
1359		base = ctf_add_union(cup->cu_ctfp, isroot, name);
1360	}
1361	ctf_dprintf("added sou %s (%d) (%d)\n", name, kind, base);
1362	if (name != NULL)
1363		ctf_free(name, strlen(name) + 1);
1364	if (base == CTF_ERR)
1365		return (ctf_errno(cup->cu_ctfp));
1366	*idp = base;
1367
1368	/*
1369	 * If it's just a declaration, we're not going to mark it for fix up or
1370	 * do anything else.
1371	 */
1372	if (decl == B_TRUE)
1373		return (ctf_dwmap_add(cup, base, die, B_FALSE));
1374	if ((ret = ctf_dwmap_add(cup, base, die, B_TRUE)) != 0)
1375		return (ret);
1376
1377	/*
1378	 * Members are in children. However, gcc also allows empty ones.
1379	 */
1380	if ((ret = ctf_dwarf_child(cup, die, &child)) != 0)
1381		return (ret);
1382	if (child == NULL)
1383		return (0);
1384
1385	return (0);
1386}
1387
1388static int
1389ctf_dwarf_create_array_range(ctf_cu_t *cup, Dwarf_Die range, ctf_id_t *idp,
1390    ctf_id_t base, int isroot)
1391{
1392	int ret;
1393	Dwarf_Die sib;
1394	Dwarf_Unsigned val;
1395	Dwarf_Signed sval;
1396	ctf_arinfo_t ar;
1397
1398	ctf_dprintf("creating array range\n");
1399
1400	if ((ret = ctf_dwarf_sib(cup, range, &sib)) != 0)
1401		return (ret);
1402	if (sib != NULL) {
1403		ctf_id_t id;
1404		if ((ret = ctf_dwarf_create_array_range(cup, sib, &id,
1405		    base, CTF_ADD_NONROOT)) != 0)
1406			return (ret);
1407		ar.ctr_contents = id;
1408	} else {
1409		ar.ctr_contents = base;
1410	}
1411
1412	if ((ar.ctr_index = ctf_dwarf_long(cup)) == CTF_ERR)
1413		return (ctf_errno(cup->cu_ctfp));
1414
1415	/*
1416	 * Array bounds can be signed or unsigned, but there are several kinds
1417	 * of signless forms (data1, data2, etc) that take their sign from the
1418	 * routine that is trying to interpret them.  That is, data1 can be
1419	 * either signed or unsigned, depending on whether you use the signed or
1420	 * unsigned accessor function.  GCC will use the signless forms to store
1421	 * unsigned values which have their high bit set, so we need to try to
1422	 * read them first as unsigned to get positive values.  We could also
1423	 * try signed first, falling back to unsigned if we got a negative
1424	 * value.
1425	 */
1426	if ((ret = ctf_dwarf_unsigned(cup, range, DW_AT_upper_bound,
1427	    &val)) == 0) {
1428		ar.ctr_nelems = val + 1;
1429	} else if (ret != ENOENT) {
1430		return (ret);
1431	} else if ((ret = ctf_dwarf_signed(cup, range, DW_AT_upper_bound,
1432	    &sval)) == 0) {
1433		ar.ctr_nelems = sval + 1;
1434	} else if (ret != ENOENT) {
1435		return (ret);
1436	} else {
1437		ar.ctr_nelems = 0;
1438	}
1439
1440	if ((*idp = ctf_add_array(cup->cu_ctfp, isroot, &ar)) == CTF_ERR)
1441		return (ctf_errno(cup->cu_ctfp));
1442
1443	return (0);
1444}
1445
1446/*
1447 * Try and create an array type. First, the kind of the array is specified in
1448 * the DW_AT_type entry. Next, the number of entries is stored in a more
1449 * complicated form, we should have a child that has the DW_TAG_subrange type.
1450 */
1451static int
1452ctf_dwarf_create_array(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, int isroot)
1453{
1454	int ret;
1455	Dwarf_Die tdie, rdie;
1456	ctf_id_t tid;
1457	Dwarf_Half rtag;
1458
1459	if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &tdie)) != 0)
1460		return (ret);
1461	if ((ret = ctf_dwarf_convert_type(cup, tdie, &tid,
1462	    CTF_ADD_NONROOT)) != 0)
1463		return (ret);
1464
1465	if ((ret = ctf_dwarf_child(cup, die, &rdie)) != 0)
1466		return (ret);
1467	if ((ret = ctf_dwarf_tag(cup, rdie, &rtag)) != 0)
1468		return (ret);
1469	if (rtag != DW_TAG_subrange_type) {
1470		(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
1471		    "encountered array without DW_TAG_subrange_type child\n");
1472		return (ECTF_CONVBKERR);
1473	}
1474
1475	/*
1476	 * The compiler may opt to describe a multi-dimensional array as one
1477	 * giant array or it may opt to instead encode it as a series of
1478	 * subranges. If it's the latter, then for each subrange we introduce a
1479	 * type. We can always use the base type.
1480	 */
1481	if ((ret = ctf_dwarf_create_array_range(cup, rdie, idp, tid,
1482	    isroot)) != 0)
1483		return (ret);
1484	ctf_dprintf("Got back id %d\n", *idp);
1485	return (ctf_dwmap_add(cup, *idp, die, B_FALSE));
1486}
1487
1488/*
1489 * Given "const int const_array3[11]", GCC7 at least will create a DIE tree of
1490 * DW_TAG_const_type:DW_TAG_array_type:DW_Tag_const_type:<member_type>.
1491 *
1492 * Given C's syntax, this renders out as "const const int const_array3[11]".  To
1493 * get closer to round-tripping (and make the unit tests work), we'll peek for
1494 * this case, and avoid adding the extraneous qualifier if we see that the
1495 * underlying array referent already has the same qualifier.
1496 *
1497 * This is unfortunately less trivial than it could be: this issue applies to
1498 * qualifier sets like "const volatile", as well as multi-dimensional arrays, so
1499 * we need to descend down those.
1500 *
1501 * Returns CTF_ERR on error, or a boolean value otherwise.
1502 */
1503static int
1504needed_array_qualifier(ctf_cu_t *cup, int kind, ctf_id_t ref_id)
1505{
1506	const ctf_type_t *t;
1507	ctf_arinfo_t arinfo;
1508	int akind;
1509
1510	if (kind != CTF_K_CONST && kind != CTF_K_VOLATILE &&
1511	    kind != CTF_K_RESTRICT)
1512		return (1);
1513
1514	if ((t = ctf_dyn_lookup_by_id(cup->cu_ctfp, ref_id)) == NULL)
1515		return (CTF_ERR);
1516
1517	if (LCTF_INFO_KIND(cup->cu_ctfp, t->ctt_info) != CTF_K_ARRAY)
1518		return (1);
1519
1520	if (ctf_dyn_array_info(cup->cu_ctfp, ref_id, &arinfo) != 0)
1521		return (CTF_ERR);
1522
1523	ctf_id_t id = arinfo.ctr_contents;
1524
1525	for (;;) {
1526		if ((t = ctf_dyn_lookup_by_id(cup->cu_ctfp, id)) == NULL)
1527			return (CTF_ERR);
1528
1529		akind = LCTF_INFO_KIND(cup->cu_ctfp, t->ctt_info);
1530
1531		if (akind == kind)
1532			break;
1533
1534		if (akind == CTF_K_ARRAY) {
1535			if (ctf_dyn_array_info(cup->cu_ctfp,
1536			    id, &arinfo) != 0)
1537				return (CTF_ERR);
1538			id = arinfo.ctr_contents;
1539			continue;
1540		}
1541
1542		if (akind != CTF_K_CONST && akind != CTF_K_VOLATILE &&
1543		    akind != CTF_K_RESTRICT)
1544			break;
1545
1546		id = t->ctt_type;
1547	}
1548
1549	if (kind == akind) {
1550		ctf_dprintf("ignoring extraneous %s qualifier for array %d\n",
1551		    ctf_kind_name(cup->cu_ctfp, kind), ref_id);
1552	}
1553
1554	return (kind != akind);
1555}
1556
1557static int
1558ctf_dwarf_create_reference(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp,
1559    int kind, int isroot)
1560{
1561	int ret;
1562	ctf_id_t id;
1563	Dwarf_Die tdie;
1564	char *name;
1565	size_t namelen;
1566
1567	if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0 &&
1568	    ret != ENOENT)
1569		return (ret);
1570	if (ret == ENOENT) {
1571		name = NULL;
1572		namelen = 0;
1573	} else {
1574		namelen = strlen(name);
1575	}
1576
1577	ctf_dprintf("reference kind %d %s\n", kind, name != NULL ? name : "<>");
1578
1579	if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &tdie)) != 0) {
1580		if (ret != ENOENT) {
1581			ctf_free(name, namelen);
1582			return (ret);
1583		}
1584		if ((id = ctf_dwarf_void(cup)) == CTF_ERR) {
1585			ctf_free(name, namelen);
1586			return (ctf_errno(cup->cu_ctfp));
1587		}
1588	} else {
1589		if ((ret = ctf_dwarf_convert_type(cup, tdie, &id,
1590		    CTF_ADD_NONROOT)) != 0) {
1591			ctf_free(name, namelen);
1592			return (ret);
1593		}
1594	}
1595
1596	if ((ret = needed_array_qualifier(cup, kind, id)) <= 0) {
1597		if (ret != 0) {
1598			ret = (ctf_errno(cup->cu_ctfp));
1599		} else {
1600			*idp = id;
1601		}
1602
1603		ctf_free(name, namelen);
1604		return (ret);
1605	}
1606
1607	if ((*idp = ctf_add_reftype(cup->cu_ctfp, isroot, name, id, kind)) ==
1608	    CTF_ERR) {
1609		ctf_free(name, namelen);
1610		return (ctf_errno(cup->cu_ctfp));
1611	}
1612
1613	ctf_free(name, namelen);
1614	return (ctf_dwmap_add(cup, *idp, die, B_FALSE));
1615}
1616
1617static int
1618ctf_dwarf_create_enum(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, int isroot)
1619{
1620	int ret;
1621	ctf_id_t id;
1622	Dwarf_Die child;
1623	char *name;
1624
1625	if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0 &&
1626	    ret != ENOENT)
1627		return (ret);
1628	if (ret == ENOENT)
1629		name = NULL;
1630	id = ctf_add_enum(cup->cu_ctfp, isroot, name);
1631	ctf_dprintf("added enum %s (%d)\n", name, id);
1632	if (name != NULL)
1633		ctf_free(name, strlen(name) + 1);
1634	if (id == CTF_ERR)
1635		return (ctf_errno(cup->cu_ctfp));
1636	*idp = id;
1637	if ((ret = ctf_dwmap_add(cup, id, die, B_FALSE)) != 0)
1638		return (ret);
1639
1640	if ((ret = ctf_dwarf_child(cup, die, &child)) != 0) {
1641		if (ret == ENOENT)
1642			ret = 0;
1643		return (ret);
1644	}
1645
1646	while (child != NULL) {
1647		Dwarf_Half tag;
1648		Dwarf_Signed sval;
1649		Dwarf_Unsigned uval;
1650		Dwarf_Die arg = child;
1651		int eval;
1652
1653		if ((ret = ctf_dwarf_sib(cup, arg, &child)) != 0)
1654			return (ret);
1655
1656		if ((ret = ctf_dwarf_tag(cup, arg, &tag)) != 0)
1657			return (ret);
1658
1659		if (tag != DW_TAG_enumerator) {
1660			if ((ret = ctf_dwarf_convert_type(cup, arg, NULL,
1661			    CTF_ADD_NONROOT)) != 0)
1662				return (ret);
1663			continue;
1664		}
1665
1666		/*
1667		 * DWARF v4 section 5.7 tells us we'll always have names.
1668		 */
1669		if ((ret = ctf_dwarf_string(cup, arg, DW_AT_name, &name)) != 0)
1670			return (ret);
1671
1672		/*
1673		 * We have to be careful here: newer GCCs generate DWARF where
1674		 * an unsigned value will happily pass ctf_dwarf_signed().
1675		 * Since negative values will fail ctf_dwarf_unsigned(), we try
1676		 * that first to make sure we get the right value.
1677		 */
1678		if ((ret = ctf_dwarf_unsigned(cup, arg, DW_AT_const_value,
1679		    &uval)) == 0) {
1680			eval = (int)uval;
1681		} else if ((ret = ctf_dwarf_signed(cup, arg, DW_AT_const_value,
1682		    &sval)) == 0) {
1683			eval = sval;
1684		}
1685
1686		if (ret != 0) {
1687			if (ret != ENOENT)
1688				return (ret);
1689
1690			(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
1691			    "encountered enumeration without constant value\n");
1692			return (ECTF_CONVBKERR);
1693		}
1694
1695		ret = ctf_add_enumerator(cup->cu_ctfp, id, name, eval);
1696		if (ret == CTF_ERR) {
1697			(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
1698			    "failed to add enumarator %s (%d) to %d\n",
1699			    name, eval, id);
1700			ctf_free(name, strlen(name) + 1);
1701			return (ctf_errno(cup->cu_ctfp));
1702		}
1703		ctf_free(name, strlen(name) + 1);
1704	}
1705
1706	return (0);
1707}
1708
1709/*
1710 * For a function pointer, walk over and process all of its children, unless we
1711 * encounter one that's just a declaration. In which case, we error on it.
1712 */
1713static int
1714ctf_dwarf_create_fptr(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, int isroot)
1715{
1716	int ret;
1717	Dwarf_Bool b;
1718	ctf_funcinfo_t fi;
1719	Dwarf_Die retdie;
1720	ctf_id_t *argv = NULL;
1721
1722	bzero(&fi, sizeof (ctf_funcinfo_t));
1723
1724	if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_declaration, &b)) != 0) {
1725		if (ret != ENOENT)
1726			return (ret);
1727	} else {
1728		if (b != 0)
1729			return (EPROTOTYPE);
1730	}
1731
1732	/*
1733	 * Return type is in DW_AT_type, if none, it returns void.
1734	 */
1735	if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &retdie)) != 0) {
1736		if (ret != ENOENT)
1737			return (ret);
1738		if ((fi.ctc_return = ctf_dwarf_void(cup)) == CTF_ERR)
1739			return (ctf_errno(cup->cu_ctfp));
1740	} else {
1741		if ((ret = ctf_dwarf_convert_type(cup, retdie, &fi.ctc_return,
1742		    CTF_ADD_NONROOT)) != 0)
1743			return (ret);
1744	}
1745
1746	if ((ret = ctf_dwarf_function_count(cup, die, &fi, B_TRUE)) != 0) {
1747		return (ret);
1748	}
1749
1750	if (fi.ctc_argc != 0) {
1751		argv = ctf_alloc(sizeof (ctf_id_t) * fi.ctc_argc);
1752		if (argv == NULL)
1753			return (ENOMEM);
1754
1755		if ((ret = ctf_dwarf_convert_fargs(cup, die, &fi, argv)) != 0) {
1756			ctf_free(argv, sizeof (ctf_id_t) * fi.ctc_argc);
1757			return (ret);
1758		}
1759	}
1760
1761	if ((*idp = ctf_add_funcptr(cup->cu_ctfp, isroot, &fi, argv)) ==
1762	    CTF_ERR) {
1763		ctf_free(argv, sizeof (ctf_id_t) * fi.ctc_argc);
1764		return (ctf_errno(cup->cu_ctfp));
1765	}
1766
1767	ctf_free(argv, sizeof (ctf_id_t) * fi.ctc_argc);
1768	return (ctf_dwmap_add(cup, *idp, die, B_FALSE));
1769}
1770
1771static int
1772ctf_dwarf_convert_type(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp,
1773    int isroot)
1774{
1775	int ret;
1776	Dwarf_Off offset;
1777	Dwarf_Half tag;
1778	ctf_dwmap_t lookup, *map;
1779	ctf_id_t id;
1780
1781	if (idp == NULL)
1782		idp = &id;
1783
1784	if ((ret = ctf_dwarf_offset(cup, die, &offset)) != 0)
1785		return (ret);
1786
1787	if (offset > cup->cu_maxoff) {
1788		(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
1789		    "die offset %llu beyond maximum for header %llu\n",
1790		    offset, cup->cu_maxoff);
1791		return (ECTF_CONVBKERR);
1792	}
1793
1794	/*
1795	 * If we've already added an entry for this offset, then we're done.
1796	 */
1797	lookup.cdm_off = offset;
1798	if ((map = avl_find(&cup->cu_map, &lookup, NULL)) != NULL) {
1799		*idp = map->cdm_id;
1800		return (0);
1801	}
1802
1803	if ((ret = ctf_dwarf_tag(cup, die, &tag)) != 0)
1804		return (ret);
1805
1806	ret = ENOTSUP;
1807	switch (tag) {
1808	case DW_TAG_base_type:
1809		ctf_dprintf("base\n");
1810		ret = ctf_dwarf_create_base(cup, die, idp, isroot, offset);
1811		break;
1812	case DW_TAG_array_type:
1813		ctf_dprintf("array\n");
1814		ret = ctf_dwarf_create_array(cup, die, idp, isroot);
1815		break;
1816	case DW_TAG_enumeration_type:
1817		ctf_dprintf("enum\n");
1818		ret = ctf_dwarf_create_enum(cup, die, idp, isroot);
1819		break;
1820	case DW_TAG_pointer_type:
1821		ctf_dprintf("pointer\n");
1822		ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_POINTER,
1823		    isroot);
1824		break;
1825	case DW_TAG_structure_type:
1826		ctf_dprintf("struct\n");
1827		ret = ctf_dwarf_create_sou(cup, die, idp, CTF_K_STRUCT,
1828		    isroot);
1829		break;
1830	case DW_TAG_subroutine_type:
1831		ctf_dprintf("fptr\n");
1832		ret = ctf_dwarf_create_fptr(cup, die, idp, isroot);
1833		break;
1834	case DW_TAG_typedef:
1835		ctf_dprintf("typedef\n");
1836		ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_TYPEDEF,
1837		    isroot);
1838		break;
1839	case DW_TAG_union_type:
1840		ctf_dprintf("union\n");
1841		ret = ctf_dwarf_create_sou(cup, die, idp, CTF_K_UNION,
1842		    isroot);
1843		break;
1844	case DW_TAG_const_type:
1845		ctf_dprintf("const\n");
1846		ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_CONST,
1847		    isroot);
1848		break;
1849	case DW_TAG_volatile_type:
1850		ctf_dprintf("volatile\n");
1851		ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_VOLATILE,
1852		    isroot);
1853		break;
1854	case DW_TAG_restrict_type:
1855		ctf_dprintf("restrict\n");
1856		ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_RESTRICT,
1857		    isroot);
1858		break;
1859	default:
1860		ctf_dprintf("ignoring tag type %x\n", tag);
1861		*idp = CTF_ERR;
1862		ret = 0;
1863		break;
1864	}
1865	ctf_dprintf("ctf_dwarf_convert_type tag specific handler returned %d\n",
1866	    ret);
1867
1868	return (ret);
1869}
1870
1871static int
1872ctf_dwarf_walk_lexical(ctf_cu_t *cup, Dwarf_Die die)
1873{
1874	int ret;
1875	Dwarf_Die child;
1876
1877	if ((ret = ctf_dwarf_child(cup, die, &child)) != 0)
1878		return (ret);
1879
1880	if (child == NULL)
1881		return (0);
1882
1883	return (ctf_dwarf_convert_die(cup, die));
1884}
1885
1886static int
1887ctf_dwarf_function_count(ctf_cu_t *cup, Dwarf_Die die, ctf_funcinfo_t *fip,
1888    boolean_t fptr)
1889{
1890	int ret;
1891	Dwarf_Die child, sib, arg;
1892
1893	if ((ret = ctf_dwarf_child(cup, die, &child)) != 0)
1894		return (ret);
1895
1896	arg = child;
1897	while (arg != NULL) {
1898		Dwarf_Half tag;
1899
1900		if ((ret = ctf_dwarf_tag(cup, arg, &tag)) != 0)
1901			return (ret);
1902
1903		/*
1904		 * We have to check for a varargs type declaration. This will
1905		 * happen in one of two ways. If we have a function pointer
1906		 * type, then it'll be done with a tag of type
1907		 * DW_TAG_unspecified_parameters. However, it only means we have
1908		 * a variable number of arguments, if we have more than one
1909		 * argument found so far. Otherwise, when we have a function
1910		 * type, it instead uses a formal parameter whose name is '...'
1911		 * to indicate a variable arguments member.
1912		 *
1913		 * Also, if we have a function pointer, then we have to expect
1914		 * that we might not get a name at all.
1915		 */
1916		if (tag == DW_TAG_formal_parameter && fptr == B_FALSE) {
1917			char *name;
1918			if ((ret = ctf_dwarf_string(cup, die, DW_AT_name,
1919			    &name)) != 0)
1920				return (ret);
1921			if (strcmp(name, DWARF_VARARGS_NAME) == 0)
1922				fip->ctc_flags |= CTF_FUNC_VARARG;
1923			else
1924				fip->ctc_argc++;
1925			ctf_free(name, strlen(name) + 1);
1926		} else if (tag == DW_TAG_formal_parameter) {
1927			fip->ctc_argc++;
1928		} else if (tag == DW_TAG_unspecified_parameters &&
1929		    fip->ctc_argc > 0) {
1930			fip->ctc_flags |= CTF_FUNC_VARARG;
1931		}
1932		if ((ret = ctf_dwarf_sib(cup, arg, &sib)) != 0)
1933			return (ret);
1934		arg = sib;
1935	}
1936
1937	return (0);
1938}
1939
1940static int
1941ctf_dwarf_convert_fargs(ctf_cu_t *cup, Dwarf_Die die, ctf_funcinfo_t *fip,
1942    ctf_id_t *argv)
1943{
1944	int ret;
1945	int i = 0;
1946	Dwarf_Die child, sib, arg;
1947
1948	if ((ret = ctf_dwarf_child(cup, die, &child)) != 0)
1949		return (ret);
1950
1951	arg = child;
1952	while (arg != NULL) {
1953		Dwarf_Half tag;
1954
1955		if ((ret = ctf_dwarf_tag(cup, arg, &tag)) != 0)
1956			return (ret);
1957		if (tag == DW_TAG_formal_parameter) {
1958			Dwarf_Die tdie;
1959
1960			if ((ret = ctf_dwarf_refdie(cup, arg, DW_AT_type,
1961			    &tdie)) != 0)
1962				return (ret);
1963
1964			if ((ret = ctf_dwarf_convert_type(cup, tdie, &argv[i],
1965			    CTF_ADD_ROOT)) != 0)
1966				return (ret);
1967			i++;
1968
1969			/*
1970			 * Once we hit argc entries, we're done. This ensures we
1971			 * don't accidentally hit a varargs which should be the
1972			 * last entry.
1973			 */
1974			if (i == fip->ctc_argc)
1975				break;
1976		}
1977
1978		if ((ret = ctf_dwarf_sib(cup, arg, &sib)) != 0)
1979			return (ret);
1980		arg = sib;
1981	}
1982
1983	return (0);
1984}
1985
1986static int
1987ctf_dwarf_convert_function(ctf_cu_t *cup, Dwarf_Die die)
1988{
1989	ctf_dwfunc_t *cdf;
1990	Dwarf_Die tdie;
1991	Dwarf_Bool b;
1992	char *name;
1993	int ret;
1994
1995	/*
1996	 * Functions that don't have a name are generally functions that have
1997	 * been inlined and thus most information about them has been lost. If
1998	 * we can't get a name, then instead of returning ENOENT, we silently
1999	 * swallow the error.
2000	 */
2001	if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0) {
2002		if (ret == ENOENT)
2003			return (0);
2004		return (ret);
2005	}
2006
2007	ctf_dprintf("beginning work on function %s (die %llx)\n",
2008	    name, ctf_die_offset(die));
2009
2010	if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_declaration, &b)) != 0) {
2011		if (ret != ENOENT)
2012			return (ret);
2013	} else if (b != 0) {
2014		/*
2015		 * GCC7 at least creates empty DW_AT_declarations for functions
2016		 * defined in headers.  As they lack details on the function
2017		 * prototype, we need to ignore them.  If we later actually
2018		 * see the relevant function's definition, we will see another
2019		 * DW_TAG_subprogram that is more complete.
2020		 */
2021		ctf_dprintf("ignoring declaration of function %s (die %llx)\n",
2022		    name, ctf_die_offset(die));
2023		return (0);
2024	}
2025
2026	if ((cdf = ctf_alloc(sizeof (ctf_dwfunc_t))) == NULL) {
2027		ctf_free(name, strlen(name) + 1);
2028		return (ENOMEM);
2029	}
2030	bzero(cdf, sizeof (ctf_dwfunc_t));
2031	cdf->cdf_name = name;
2032
2033	if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &tdie)) == 0) {
2034		if ((ret = ctf_dwarf_convert_type(cup, tdie,
2035		    &(cdf->cdf_fip.ctc_return), CTF_ADD_ROOT)) != 0) {
2036			ctf_free(name, strlen(name) + 1);
2037			ctf_free(cdf, sizeof (ctf_dwfunc_t));
2038			return (ret);
2039		}
2040	} else if (ret != ENOENT) {
2041		ctf_free(name, strlen(name) + 1);
2042		ctf_free(cdf, sizeof (ctf_dwfunc_t));
2043		return (ret);
2044	} else {
2045		if ((cdf->cdf_fip.ctc_return = ctf_dwarf_void(cup)) ==
2046		    CTF_ERR) {
2047			ctf_free(name, strlen(name) + 1);
2048			ctf_free(cdf, sizeof (ctf_dwfunc_t));
2049			return (ctf_errno(cup->cu_ctfp));
2050		}
2051	}
2052
2053	/*
2054	 * A function has a number of children, some of which may not be ones we
2055	 * care about. Children that we care about have a type of
2056	 * DW_TAG_formal_parameter. We're going to do two passes, the first to
2057	 * count the arguments, the second to process them. Afterwards, we
2058	 * should be good to go ahead and add this function.
2059	 *
2060	 * Note, we already got the return type by going in and grabbing it out
2061	 * of the DW_AT_type.
2062	 */
2063	if ((ret = ctf_dwarf_function_count(cup, die, &cdf->cdf_fip,
2064	    B_FALSE)) != 0) {
2065		ctf_free(name, strlen(name) + 1);
2066		ctf_free(cdf, sizeof (ctf_dwfunc_t));
2067		return (ret);
2068	}
2069
2070	ctf_dprintf("beginning to convert function arguments %s\n", name);
2071	if (cdf->cdf_fip.ctc_argc != 0) {
2072		uint_t argc = cdf->cdf_fip.ctc_argc;
2073		cdf->cdf_argv = ctf_alloc(sizeof (ctf_id_t) * argc);
2074		if (cdf->cdf_argv == NULL) {
2075			ctf_free(name, strlen(name) + 1);
2076			ctf_free(cdf, sizeof (ctf_dwfunc_t));
2077			return (ENOMEM);
2078		}
2079		if ((ret = ctf_dwarf_convert_fargs(cup, die,
2080		    &cdf->cdf_fip, cdf->cdf_argv)) != 0) {
2081			ctf_free(cdf->cdf_argv, sizeof (ctf_id_t) * argc);
2082			ctf_free(name, strlen(name) + 1);
2083			ctf_free(cdf, sizeof (ctf_dwfunc_t));
2084			return (ret);
2085		}
2086	} else {
2087		cdf->cdf_argv = NULL;
2088	}
2089
2090	if ((ret = ctf_dwarf_isglobal(cup, die, &cdf->cdf_global)) != 0) {
2091		ctf_free(cdf->cdf_argv, sizeof (ctf_id_t) *
2092		    cdf->cdf_fip.ctc_argc);
2093		ctf_free(name, strlen(name) + 1);
2094		ctf_free(cdf, sizeof (ctf_dwfunc_t));
2095		return (ret);
2096	}
2097
2098	ctf_list_append(&cup->cu_funcs, cdf);
2099	return (ret);
2100}
2101
2102/*
2103 * Convert variables, but only if they're not prototypes and have names.
2104 */
2105static int
2106ctf_dwarf_convert_variable(ctf_cu_t *cup, Dwarf_Die die)
2107{
2108	int ret;
2109	char *name;
2110	Dwarf_Bool b;
2111	Dwarf_Die tdie;
2112	ctf_id_t id;
2113	ctf_dwvar_t *cdv;
2114
2115	/* Skip "Non-Defining Declarations" */
2116	if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_declaration, &b)) == 0) {
2117		if (b != 0)
2118			return (0);
2119	} else if (ret != ENOENT) {
2120		return (ret);
2121	}
2122
2123	/*
2124	 * If we find a DIE of "Declarations Completing Non-Defining
2125	 * Declarations", we will use the referenced type's DIE.  This isn't
2126	 * quite correct, e.g. DW_AT_decl_line will be the forward declaration
2127	 * not this site.  It's sufficient for what we need, however: in
2128	 * particular, we should find DW_AT_external as needed there.
2129	 */
2130	if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_specification,
2131	    &tdie)) == 0) {
2132		Dwarf_Off offset;
2133		if ((ret = ctf_dwarf_offset(cup, tdie, &offset)) != 0)
2134			return (ret);
2135		ctf_dprintf("die 0x%llx DW_AT_specification -> die 0x%llx\n",
2136		    ctf_die_offset(die), ctf_die_offset(tdie));
2137		die = tdie;
2138	} else if (ret != ENOENT) {
2139		return (ret);
2140	}
2141
2142	if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0 &&
2143	    ret != ENOENT)
2144		return (ret);
2145	if (ret == ENOENT)
2146		return (0);
2147
2148	if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &tdie)) != 0) {
2149		ctf_free(name, strlen(name) + 1);
2150		return (ret);
2151	}
2152
2153	if ((ret = ctf_dwarf_convert_type(cup, tdie, &id,
2154	    CTF_ADD_ROOT)) != 0)
2155		return (ret);
2156
2157	if ((cdv = ctf_alloc(sizeof (ctf_dwvar_t))) == NULL) {
2158		ctf_free(name, strlen(name) + 1);
2159		return (ENOMEM);
2160	}
2161
2162	cdv->cdv_name = name;
2163	cdv->cdv_type = id;
2164
2165	if ((ret = ctf_dwarf_isglobal(cup, die, &cdv->cdv_global)) != 0) {
2166		ctf_free(cdv, sizeof (ctf_dwvar_t));
2167		ctf_free(name, strlen(name) + 1);
2168		return (ret);
2169	}
2170
2171	ctf_list_append(&cup->cu_vars, cdv);
2172	return (0);
2173}
2174
2175/*
2176 * Walk through our set of top-level types and process them.
2177 */
2178static int
2179ctf_dwarf_walk_toplevel(ctf_cu_t *cup, Dwarf_Die die)
2180{
2181	int ret;
2182	Dwarf_Off offset;
2183	Dwarf_Half tag;
2184
2185	if ((ret = ctf_dwarf_offset(cup, die, &offset)) != 0)
2186		return (ret);
2187
2188	if (offset > cup->cu_maxoff) {
2189		(void) snprintf(cup->cu_errbuf, cup->cu_errlen,
2190		    "die offset %llu beyond maximum for header %llu\n",
2191		    offset, cup->cu_maxoff);
2192		return (ECTF_CONVBKERR);
2193	}
2194
2195	if ((ret = ctf_dwarf_tag(cup, die, &tag)) != 0)
2196		return (ret);
2197
2198	ret = 0;
2199	switch (tag) {
2200	case DW_TAG_subprogram:
2201		ctf_dprintf("top level func\n");
2202		ret = ctf_dwarf_convert_function(cup, die);
2203		break;
2204	case DW_TAG_variable:
2205		ctf_dprintf("top level var\n");
2206		ret = ctf_dwarf_convert_variable(cup, die);
2207		break;
2208	case DW_TAG_lexical_block:
2209		ctf_dprintf("top level block\n");
2210		ret = ctf_dwarf_walk_lexical(cup, die);
2211		break;
2212	case DW_TAG_enumeration_type:
2213	case DW_TAG_structure_type:
2214	case DW_TAG_typedef:
2215	case DW_TAG_union_type:
2216		ctf_dprintf("top level type\n");
2217		ret = ctf_dwarf_convert_type(cup, die, NULL, B_TRUE);
2218		break;
2219	default:
2220		break;
2221	}
2222
2223	return (ret);
2224}
2225
2226
2227/*
2228 * We're given a node. At this node we need to convert it and then proceed to
2229 * convert any siblings that are associaed with this die.
2230 */
2231static int
2232ctf_dwarf_convert_die(ctf_cu_t *cup, Dwarf_Die die)
2233{
2234	while (die != NULL) {
2235		int ret;
2236		Dwarf_Die sib;
2237
2238		if ((ret = ctf_dwarf_walk_toplevel(cup, die)) != 0)
2239			return (ret);
2240
2241		if ((ret = ctf_dwarf_sib(cup, die, &sib)) != 0)
2242			return (ret);
2243		die = sib;
2244	}
2245	return (0);
2246}
2247
2248static int
2249ctf_dwarf_fixup_die(ctf_cu_t *cup, boolean_t addpass)
2250{
2251	ctf_dwmap_t *map;
2252
2253	for (map = avl_first(&cup->cu_map); map != NULL;
2254	    map = AVL_NEXT(&cup->cu_map, map)) {
2255		int ret;
2256		if (map->cdm_fix == B_FALSE)
2257			continue;
2258		if ((ret = ctf_dwarf_fixup_sou(cup, map->cdm_die, map->cdm_id,
2259		    addpass)) != 0)
2260			return (ret);
2261	}
2262
2263	return (0);
2264}
2265
2266/*
2267 * The DWARF information about a symbol and the information in the symbol table
2268 * may not be the same due to symbol reduction that is performed by ld due to a
2269 * mapfile or other such directive. We process weak symbols at a later time.
2270 *
2271 * The following are the rules that we employ:
2272 *
2273 * 1. A DWARF function that is considered exported matches STB_GLOBAL entries
2274 * with the same name.
2275 *
2276 * 2. A DWARF function that is considered exported matches STB_LOCAL entries
2277 * with the same name and the same file. This case may happen due to mapfile
2278 * reduction.
2279 *
2280 * 3. A DWARF function that is not considered exported matches STB_LOCAL entries
2281 * with the same name and the same file.
2282 *
2283 * 4. A DWARF function that has the same name as the symbol table entry, but the
2284 * files do not match. This is considered a 'fuzzy' match. This may also happen
2285 * due to a mapfile reduction. Fuzzy matching is only used when we know that the
2286 * file in question refers to the primary object. This is because when a symbol
2287 * is reduced in a mapfile, it's always going to be tagged as a local value in
2288 * the generated output and it is considered as to belong to the primary file
2289 * which is the first STT_FILE symbol we see.
2290 */
2291static boolean_t
2292ctf_dwarf_symbol_match(const char *symtab_file, const char *symtab_name,
2293    uint_t symtab_bind, const char *dwarf_file, const char *dwarf_name,
2294    boolean_t dwarf_global, boolean_t *is_fuzzy)
2295{
2296	*is_fuzzy = B_FALSE;
2297
2298	if (symtab_bind != STB_LOCAL && symtab_bind != STB_GLOBAL) {
2299		return (B_FALSE);
2300	}
2301
2302	if (strcmp(symtab_name, dwarf_name) != 0) {
2303		return (B_FALSE);
2304	}
2305
2306	if (symtab_bind == STB_GLOBAL) {
2307		return (dwarf_global);
2308	}
2309
2310	if (strcmp(symtab_file, dwarf_file) == 0) {
2311		return (B_TRUE);
2312	}
2313
2314	if (dwarf_global) {
2315		*is_fuzzy = B_TRUE;
2316		return (B_TRUE);
2317	}
2318
2319	return (B_FALSE);
2320}
2321
2322static ctf_dwfunc_t *
2323ctf_dwarf_match_func(ctf_cu_t *cup, const char *file, const char *name,
2324    uint_t bind, boolean_t primary)
2325{
2326	ctf_dwfunc_t *cdf, *fuzzy = NULL;
2327
2328	if (bind == STB_WEAK)
2329		return (NULL);
2330
2331	if (bind == STB_LOCAL && (file == NULL || cup->cu_name == NULL))
2332		return (NULL);
2333
2334	for (cdf = ctf_list_next(&cup->cu_funcs); cdf != NULL;
2335	    cdf = ctf_list_next(cdf)) {
2336		boolean_t is_fuzzy = B_FALSE;
2337
2338		if (ctf_dwarf_symbol_match(file, name, bind, cup->cu_name,
2339		    cdf->cdf_name, cdf->cdf_global, &is_fuzzy)) {
2340			if (is_fuzzy) {
2341				if (primary) {
2342					fuzzy = cdf;
2343				}
2344				continue;
2345			} else {
2346				return (cdf);
2347			}
2348		}
2349	}
2350
2351	return (fuzzy);
2352}
2353
2354static ctf_dwvar_t *
2355ctf_dwarf_match_var(ctf_cu_t *cup, const char *file, const char *name,
2356    uint_t bind, boolean_t primary)
2357{
2358	ctf_dwvar_t *cdv, *fuzzy = NULL;
2359
2360	if (bind == STB_WEAK)
2361		return (NULL);
2362
2363	if (bind == STB_LOCAL && (file == NULL || cup->cu_name == NULL))
2364		return (NULL);
2365
2366	for (cdv = ctf_list_next(&cup->cu_vars); cdv != NULL;
2367	    cdv = ctf_list_next(cdv)) {
2368		boolean_t is_fuzzy = B_FALSE;
2369
2370		if (ctf_dwarf_symbol_match(file, name, bind, cup->cu_name,
2371		    cdv->cdv_name, cdv->cdv_global, &is_fuzzy)) {
2372			if (is_fuzzy) {
2373				if (primary) {
2374					fuzzy = cdv;
2375				}
2376			} else {
2377				return (cdv);
2378			}
2379		}
2380	}
2381
2382	return (fuzzy);
2383}
2384
2385static int
2386ctf_dwarf_conv_funcvars_cb(const Elf64_Sym *symp, ulong_t idx,
2387    const char *file, const char *name, boolean_t primary, void *arg)
2388{
2389	int ret;
2390	uint_t bind, type;
2391	ctf_cu_t *cup = arg;
2392
2393	bind = GELF_ST_BIND(symp->st_info);
2394	type = GELF_ST_TYPE(symp->st_info);
2395
2396	/*
2397	 * Come back to weak symbols in another pass
2398	 */
2399	if (bind == STB_WEAK)
2400		return (0);
2401
2402	if (type == STT_OBJECT) {
2403		ctf_dwvar_t *cdv = ctf_dwarf_match_var(cup, file, name,
2404		    bind, primary);
2405		if (cdv == NULL)
2406			return (0);
2407		ret = ctf_add_object(cup->cu_ctfp, idx, cdv->cdv_type);
2408		ctf_dprintf("added object %s->%ld\n", name, cdv->cdv_type);
2409	} else {
2410		ctf_dwfunc_t *cdf = ctf_dwarf_match_func(cup, file, name,
2411		    bind, primary);
2412		if (cdf == NULL)
2413			return (0);
2414		ret = ctf_add_function(cup->cu_ctfp, idx, &cdf->cdf_fip,
2415		    cdf->cdf_argv);
2416		ctf_dprintf("added function %s\n", name);
2417	}
2418
2419	if (ret == CTF_ERR) {
2420		return (ctf_errno(cup->cu_ctfp));
2421	}
2422
2423	return (0);
2424}
2425
2426static int
2427ctf_dwarf_conv_funcvars(ctf_cu_t *cup)
2428{
2429	return (ctf_symtab_iter(cup->cu_ctfp, ctf_dwarf_conv_funcvars_cb, cup));
2430}
2431
2432/*
2433 * If we have a weak symbol, attempt to find the strong symbol it will resolve
2434 * to.  Note: the code where this actually happens is in sym_process() in
2435 * cmd/sgs/libld/common/syms.c
2436 *
2437 * Finding the matching symbol is unfortunately not trivial.  For a symbol to be
2438 * a candidate, it must:
2439 *
2440 * - have the same type (function, object)
2441 * - have the same value (address)
2442 * - have the same size
2443 * - not be another weak symbol
2444 * - belong to the same section (checked via section index)
2445 *
2446 * To perform this check, we first iterate over the symbol table. For each weak
2447 * symbol that we encounter, we then do a second walk over the symbol table,
2448 * calling ctf_dwarf_conv_check_weak(). If a symbol matches the above, then it's
2449 * either a local or global symbol. If we find a global symbol then we go with
2450 * it and stop searching for additional matches.
2451 *
2452 * If instead, we find a local symbol, things are more complicated. The first
2453 * thing we do is to try and see if we have file information about both symbols
2454 * (STT_FILE). If they both have file information and it matches, then we treat
2455 * that as a good match and stop searching for additional matches.
2456 *
2457 * Otherwise, this means we have a non-matching file and a local symbol. We
2458 * treat this as a candidate and if we find a better match (one of the two cases
2459 * above), use that instead. There are two different ways this can happen.
2460 * Either this is a completely different symbol, or it's a once-global symbol
2461 * that was scoped to local via a mapfile.  In the former case, curfile is
2462 * likely inaccurate since the linker does not preserve the needed curfile in
2463 * the order of the symbol table (see the comments about locally scoped symbols
2464 * in libld's update_osym()).  As we can't tell this case from the former one,
2465 * we use this symbol iff no other matching symbol is found.
2466 *
2467 * What we really need here is a SUNW section containing weak<->strong mappings
2468 * that we can consume.
2469 */
2470typedef struct ctf_dwarf_weak_arg {
2471	const Elf64_Sym *cweak_symp;
2472	const char *cweak_file;
2473	boolean_t cweak_candidate;
2474	ulong_t cweak_idx;
2475} ctf_dwarf_weak_arg_t;
2476
2477static int
2478ctf_dwarf_conv_check_weak(const Elf64_Sym *symp, ulong_t idx, const char *file,
2479    const char *name, boolean_t primary, void *arg)
2480{
2481	ctf_dwarf_weak_arg_t *cweak = arg;
2482
2483	const Elf64_Sym *wsymp = cweak->cweak_symp;
2484
2485	ctf_dprintf("comparing weak to %s\n", name);
2486
2487	if (GELF_ST_BIND(symp->st_info) == STB_WEAK) {
2488		return (0);
2489	}
2490
2491	if (GELF_ST_TYPE(wsymp->st_info) != GELF_ST_TYPE(symp->st_info)) {
2492		return (0);
2493	}
2494
2495	if (wsymp->st_value != symp->st_value) {
2496		return (0);
2497	}
2498
2499	if (wsymp->st_size != symp->st_size) {
2500		return (0);
2501	}
2502
2503	if (wsymp->st_shndx != symp->st_shndx) {
2504		return (0);
2505	}
2506
2507	/*
2508	 * Check if it's a weak candidate.
2509	 */
2510	if (GELF_ST_BIND(symp->st_info) == STB_LOCAL &&
2511	    (file == NULL || cweak->cweak_file == NULL ||
2512	    strcmp(file, cweak->cweak_file) != 0)) {
2513		cweak->cweak_candidate = B_TRUE;
2514		cweak->cweak_idx = idx;
2515		return (0);
2516	}
2517
2518	/*
2519	 * Found a match, break.
2520	 */
2521	cweak->cweak_idx = idx;
2522	return (1);
2523}
2524
2525static int
2526ctf_dwarf_duplicate_sym(ctf_cu_t *cup, ulong_t idx, ulong_t matchidx)
2527{
2528	ctf_id_t id = ctf_lookup_by_symbol(cup->cu_ctfp, matchidx);
2529
2530	/*
2531	 * If we matched something that for some reason didn't have type data,
2532	 * we don't consider that a fatal error and silently swallow it.
2533	 */
2534	if (id == CTF_ERR) {
2535		if (ctf_errno(cup->cu_ctfp) == ECTF_NOTYPEDAT)
2536			return (0);
2537		else
2538			return (ctf_errno(cup->cu_ctfp));
2539	}
2540
2541	if (ctf_add_object(cup->cu_ctfp, idx, id) == CTF_ERR)
2542		return (ctf_errno(cup->cu_ctfp));
2543
2544	return (0);
2545}
2546
2547static int
2548ctf_dwarf_duplicate_func(ctf_cu_t *cup, ulong_t idx, ulong_t matchidx)
2549{
2550	int ret;
2551	ctf_funcinfo_t fip;
2552	ctf_id_t *args = NULL;
2553
2554	if (ctf_func_info(cup->cu_ctfp, matchidx, &fip) == CTF_ERR) {
2555		if (ctf_errno(cup->cu_ctfp) == ECTF_NOFUNCDAT)
2556			return (0);
2557		else
2558			return (ctf_errno(cup->cu_ctfp));
2559	}
2560
2561	if (fip.ctc_argc != 0) {
2562		args = ctf_alloc(sizeof (ctf_id_t) * fip.ctc_argc);
2563		if (args == NULL)
2564			return (ENOMEM);
2565
2566		if (ctf_func_args(cup->cu_ctfp, matchidx, fip.ctc_argc, args) ==
2567		    CTF_ERR) {
2568			ctf_free(args, sizeof (ctf_id_t) * fip.ctc_argc);
2569			return (ctf_errno(cup->cu_ctfp));
2570		}
2571	}
2572
2573	ret = ctf_add_function(cup->cu_ctfp, idx, &fip, args);
2574	if (args != NULL)
2575		ctf_free(args, sizeof (ctf_id_t) * fip.ctc_argc);
2576	if (ret == CTF_ERR)
2577		return (ctf_errno(cup->cu_ctfp));
2578
2579	return (0);
2580}
2581
2582static int
2583ctf_dwarf_conv_weaks_cb(const Elf64_Sym *symp, ulong_t idx, const char *file,
2584    const char *name, boolean_t primary, void *arg)
2585{
2586	int ret, type;
2587	ctf_dwarf_weak_arg_t cweak;
2588	ctf_cu_t *cup = arg;
2589
2590	/*
2591	 * We only care about weak symbols.
2592	 */
2593	if (GELF_ST_BIND(symp->st_info) != STB_WEAK)
2594		return (0);
2595
2596	type = GELF_ST_TYPE(symp->st_info);
2597	ASSERT(type == STT_OBJECT || type == STT_FUNC);
2598
2599	/*
2600	 * For each weak symbol we encounter, we need to do a second iteration
2601	 * to try and find a match. We should probably think about other
2602	 * techniques to try and save us time in the future.
2603	 */
2604	cweak.cweak_symp = symp;
2605	cweak.cweak_file = file;
2606	cweak.cweak_candidate = B_FALSE;
2607	cweak.cweak_idx = 0;
2608
2609	ctf_dprintf("Trying to find weak equiv for %s\n", name);
2610
2611	ret = ctf_symtab_iter(cup->cu_ctfp, ctf_dwarf_conv_check_weak, &cweak);
2612	VERIFY(ret == 0 || ret == 1);
2613
2614	/*
2615	 * Nothing was ever found, we're not going to add anything for this
2616	 * entry.
2617	 */
2618	if (ret == 0 && cweak.cweak_candidate == B_FALSE) {
2619		ctf_dprintf("found no weak match for %s\n", name);
2620		return (0);
2621	}
2622
2623	/*
2624	 * Now, finally go and add the type based on the match.
2625	 */
2626	ctf_dprintf("matched weak symbol %lu to %lu\n", idx, cweak.cweak_idx);
2627	if (type == STT_OBJECT) {
2628		ret = ctf_dwarf_duplicate_sym(cup, idx, cweak.cweak_idx);
2629	} else {
2630		ret = ctf_dwarf_duplicate_func(cup, idx, cweak.cweak_idx);
2631	}
2632
2633	return (ret);
2634}
2635
2636static int
2637ctf_dwarf_conv_weaks(ctf_cu_t *cup)
2638{
2639	return (ctf_symtab_iter(cup->cu_ctfp, ctf_dwarf_conv_weaks_cb, cup));
2640}
2641
2642/* ARGSUSED */
2643static int
2644ctf_dwarf_convert_one(void *arg, void *unused)
2645{
2646	int ret;
2647	ctf_file_t *dedup;
2648	ctf_cu_t *cup = arg;
2649
2650	ctf_dprintf("converting die: %s\n", cup->cu_name);
2651	ctf_dprintf("max offset: %x\n", cup->cu_maxoff);
2652	VERIFY(cup != NULL);
2653
2654	ret = ctf_dwarf_convert_die(cup, cup->cu_cu);
2655	ctf_dprintf("ctf_dwarf_convert_die (%s) returned %d\n", cup->cu_name,
2656	    ret);
2657	if (ret != 0) {
2658		return (ret);
2659	}
2660	if (ctf_update(cup->cu_ctfp) != 0) {
2661		return (ctf_dwarf_error(cup, cup->cu_ctfp, 0,
2662		    "failed to update output ctf container"));
2663	}
2664
2665	ret = ctf_dwarf_fixup_die(cup, B_FALSE);
2666	ctf_dprintf("ctf_dwarf_fixup_die (%s) returned %d\n", cup->cu_name,
2667	    ret);
2668	if (ret != 0) {
2669		return (ret);
2670	}
2671	if (ctf_update(cup->cu_ctfp) != 0) {
2672		return (ctf_dwarf_error(cup, cup->cu_ctfp, 0,
2673		    "failed to update output ctf container"));
2674	}
2675
2676	ret = ctf_dwarf_fixup_die(cup, B_TRUE);
2677	ctf_dprintf("ctf_dwarf_fixup_die (%s) returned %d\n", cup->cu_name,
2678	    ret);
2679	if (ret != 0) {
2680		return (ret);
2681	}
2682	if (ctf_update(cup->cu_ctfp) != 0) {
2683		return (ctf_dwarf_error(cup, cup->cu_ctfp, 0,
2684		    "failed to update output ctf container"));
2685	}
2686
2687
2688	if ((ret = ctf_dwarf_conv_funcvars(cup)) != 0) {
2689		return (ctf_dwarf_error(cup, NULL, ret,
2690		    "failed to convert strong functions and variables"));
2691	}
2692
2693	if (ctf_update(cup->cu_ctfp) != 0) {
2694		return (ctf_dwarf_error(cup, cup->cu_ctfp, 0,
2695		    "failed to update output ctf container"));
2696	}
2697
2698	if (cup->cu_doweaks == B_TRUE) {
2699		if ((ret = ctf_dwarf_conv_weaks(cup)) != 0) {
2700			return (ctf_dwarf_error(cup, NULL, ret,
2701			    "failed to convert weak functions and variables"));
2702		}
2703
2704		if (ctf_update(cup->cu_ctfp) != 0) {
2705			return (ctf_dwarf_error(cup, cup->cu_ctfp, 0,
2706			    "failed to update output ctf container"));
2707		}
2708	}
2709
2710	ctf_phase_dump(cup->cu_ctfp, "pre-dwarf-dedup", cup->cu_name);
2711	ctf_dprintf("adding inputs for dedup\n");
2712	if ((ret = ctf_merge_add(cup->cu_cmh, cup->cu_ctfp)) != 0) {
2713		return (ctf_dwarf_error(cup, NULL, ret,
2714		    "failed to add inputs for merge"));
2715	}
2716
2717	ctf_dprintf("starting dedup of %s\n", cup->cu_name);
2718	if ((ret = ctf_merge_dedup(cup->cu_cmh, &dedup)) != 0) {
2719		return (ctf_dwarf_error(cup, NULL, ret,
2720		    "failed to deduplicate die"));
2721	}
2722	ctf_close(cup->cu_ctfp);
2723	cup->cu_ctfp = dedup;
2724	ctf_phase_dump(cup->cu_ctfp, "post-dwarf-dedup", cup->cu_name);
2725
2726	return (0);
2727}
2728
2729/*
2730 * Note, we expect that if we're returning a ctf_file_t from one of the dies,
2731 * say in the single node case, it's been saved and the entry here has been set
2732 * to NULL, which ctf_close happily ignores.
2733 */
2734static void
2735ctf_dwarf_free_die(ctf_cu_t *cup)
2736{
2737	ctf_dwfunc_t *cdf, *ndf;
2738	ctf_dwvar_t *cdv, *ndv;
2739	ctf_dwbitf_t *cdb, *ndb;
2740	ctf_dwmap_t *map;
2741	void *cookie;
2742	Dwarf_Error derr;
2743
2744	ctf_dprintf("Beginning to free die: %p\n", cup);
2745	cup->cu_elf = NULL;
2746	ctf_dprintf("Trying to free name: %p\n", cup->cu_name);
2747	if (cup->cu_name != NULL)
2748		ctf_free(cup->cu_name, strlen(cup->cu_name) + 1);
2749	ctf_dprintf("Trying to free merge handle: %p\n", cup->cu_cmh);
2750	if (cup->cu_cmh != NULL) {
2751		ctf_merge_fini(cup->cu_cmh);
2752		cup->cu_cmh = NULL;
2753	}
2754
2755	ctf_dprintf("Trying to free functions\n");
2756	for (cdf = ctf_list_next(&cup->cu_funcs); cdf != NULL; cdf = ndf) {
2757		ndf = ctf_list_next(cdf);
2758		ctf_free(cdf->cdf_name, strlen(cdf->cdf_name) + 1);
2759		if (cdf->cdf_fip.ctc_argc != 0) {
2760			ctf_free(cdf->cdf_argv,
2761			    sizeof (ctf_id_t) * cdf->cdf_fip.ctc_argc);
2762		}
2763		ctf_free(cdf, sizeof (ctf_dwfunc_t));
2764	}
2765
2766	ctf_dprintf("Trying to free variables\n");
2767	for (cdv = ctf_list_next(&cup->cu_vars); cdv != NULL; cdv = ndv) {
2768		ndv = ctf_list_next(cdv);
2769		ctf_free(cdv->cdv_name, strlen(cdv->cdv_name) + 1);
2770		ctf_free(cdv, sizeof (ctf_dwvar_t));
2771	}
2772
2773	ctf_dprintf("Trying to free bitfields\n");
2774	for (cdb = ctf_list_next(&cup->cu_bitfields); cdb != NULL; cdb = ndb) {
2775		ndb = ctf_list_next(cdb);
2776		ctf_free(cdb, sizeof (ctf_dwbitf_t));
2777	}
2778
2779	ctf_dprintf("Trying to clean up dwarf_t: %p\n", cup->cu_dwarf);
2780	if (cup->cu_dwarf != NULL)
2781		(void) dwarf_finish(cup->cu_dwarf, &derr);
2782	cup->cu_dwarf = NULL;
2783	ctf_close(cup->cu_ctfp);
2784
2785	cookie = NULL;
2786	while ((map = avl_destroy_nodes(&cup->cu_map, &cookie)) != NULL) {
2787		ctf_free(map, sizeof (ctf_dwmap_t));
2788	}
2789	avl_destroy(&cup->cu_map);
2790	cup->cu_errbuf = NULL;
2791}
2792
2793static void
2794ctf_dwarf_free_dies(ctf_cu_t *cdies, int ndies)
2795{
2796	int i;
2797
2798	ctf_dprintf("Beginning to free dies\n");
2799	for (i = 0; i < ndies; i++) {
2800		ctf_dwarf_free_die(&cdies[i]);
2801	}
2802
2803	ctf_free(cdies, sizeof (ctf_cu_t) * ndies);
2804}
2805
2806static int
2807ctf_dwarf_count_dies(Dwarf_Debug dw, Dwarf_Error *derr, int *ndies,
2808    char *errbuf, size_t errlen)
2809{
2810	int ret;
2811	Dwarf_Half vers;
2812	Dwarf_Unsigned nexthdr;
2813
2814	while ((ret = dwarf_next_cu_header(dw, NULL, &vers, NULL, NULL,
2815	    &nexthdr, derr)) != DW_DLV_NO_ENTRY) {
2816		if (ret != DW_DLV_OK) {
2817			(void) snprintf(errbuf, errlen,
2818			    "file does not contain valid DWARF data: %s\n",
2819			    dwarf_errmsg(*derr));
2820			return (ECTF_CONVBKERR);
2821		}
2822
2823		if (vers != DWARF_VERSION_TWO) {
2824			(void) snprintf(errbuf, errlen,
2825			    "unsupported DWARF version: %d\n", vers);
2826			return (ECTF_CONVBKERR);
2827		}
2828		*ndies = *ndies + 1;
2829	}
2830
2831	return (0);
2832}
2833
2834static int
2835ctf_dwarf_init_die(int fd, Elf *elf, ctf_cu_t *cup, int ndie, char *errbuf,
2836    size_t errlen)
2837{
2838	int ret;
2839	Dwarf_Unsigned hdrlen, abboff, nexthdr;
2840	Dwarf_Half addrsz;
2841	Dwarf_Unsigned offset = 0;
2842	Dwarf_Error derr;
2843
2844	while ((ret = dwarf_next_cu_header(cup->cu_dwarf, &hdrlen, NULL,
2845	    &abboff, &addrsz, &nexthdr, &derr)) != DW_DLV_NO_ENTRY) {
2846		char *name;
2847		Dwarf_Die cu, child;
2848
2849		/* Based on the counting above, we should be good to go */
2850		VERIFY(ret == DW_DLV_OK);
2851		if (ndie > 0) {
2852			ndie--;
2853			offset = nexthdr;
2854			continue;
2855		}
2856
2857		/*
2858		 * Compilers are apparently inconsistent. Some emit no DWARF for
2859		 * empty files and others emit empty compilation unit.
2860		 */
2861		cup->cu_voidtid = CTF_ERR;
2862		cup->cu_longtid = CTF_ERR;
2863		cup->cu_elf = elf;
2864		cup->cu_maxoff = nexthdr - 1;
2865		cup->cu_ctfp = ctf_fdcreate(fd, &ret);
2866		if (cup->cu_ctfp == NULL)
2867			return (ret);
2868
2869		avl_create(&cup->cu_map, ctf_dwmap_comp, sizeof (ctf_dwmap_t),
2870		    offsetof(ctf_dwmap_t, cdm_avl));
2871		cup->cu_errbuf = errbuf;
2872		cup->cu_errlen = errlen;
2873		bzero(&cup->cu_vars, sizeof (ctf_list_t));
2874		bzero(&cup->cu_funcs, sizeof (ctf_list_t));
2875		bzero(&cup->cu_bitfields, sizeof (ctf_list_t));
2876
2877		if ((ret = ctf_dwarf_die_elfenc(elf, cup, errbuf,
2878		    errlen)) != 0)
2879			return (ret);
2880
2881		if ((ret = ctf_dwarf_sib(cup, NULL, &cu)) != 0)
2882			return (ret);
2883
2884		if (cu == NULL) {
2885			(void) snprintf(errbuf, errlen,
2886			    "file does not contain DWARF data");
2887			return (ECTF_CONVNODEBUG);
2888		}
2889
2890		if ((ret = ctf_dwarf_child(cup, cu, &child)) != 0)
2891			return (ret);
2892
2893		if (child == NULL) {
2894			(void) snprintf(errbuf, errlen,
2895			    "file does not contain DWARF data");
2896			return (ECTF_CONVNODEBUG);
2897		}
2898
2899		cup->cu_cuoff = offset;
2900		cup->cu_cu = child;
2901
2902		if ((cup->cu_cmh = ctf_merge_init(fd, &ret)) == NULL)
2903			return (ret);
2904
2905		if (ctf_dwarf_string(cup, cu, DW_AT_name, &name) == 0) {
2906			size_t len = strlen(name) + 1;
2907			char *b = basename(name);
2908			cup->cu_name = strdup(b);
2909			ctf_free(name, len);
2910		}
2911		break;
2912	}
2913
2914	return (0);
2915}
2916
2917/*
2918 * This is our only recourse to identify a C source file that is missing debug
2919 * info: it will be mentioned as an STT_FILE, but not have a compile unit entry.
2920 * (A traditional ctfmerge works on individual files, so can identify missing
2921 * DWARF more directly, via ctf_has_c_source() on the .o file.)
2922 *
2923 * As we operate on basenames, this can of course miss some cases, but it's
2924 * better than not checking at all.
2925 *
2926 * We explicitly whitelist some CRT components.  Failing that, there's always
2927 * the -m option.
2928 */
2929static boolean_t
2930c_source_has_debug(const char *file, ctf_cu_t *cus, size_t nr_cus)
2931{
2932	const char *basename = strrchr(file, '/');
2933
2934	if (basename == NULL)
2935		basename = file;
2936	else
2937		basename++;
2938
2939	if (strcmp(basename, "common-crt.c") == 0 ||
2940	    strcmp(basename, "gmon.c") == 0 ||
2941	    strcmp(basename, "dlink_init.c") == 0 ||
2942	    strcmp(basename, "dlink_common.c") == 0 ||
2943	    strncmp(basename, "crt", strlen("crt")) == 0 ||
2944	    strncmp(basename, "values-", strlen("values-")) == 0)
2945		return (B_TRUE);
2946
2947	for (size_t i = 0; i < nr_cus; i++) {
2948		if (strcmp(basename, cus[i].cu_name) == 0)
2949			return (B_TRUE);
2950	}
2951
2952	return (B_FALSE);
2953}
2954
2955static int
2956ctf_dwarf_check_missing(ctf_cu_t *cus, size_t nr_cus, Elf *elf,
2957    char *errmsg, size_t errlen)
2958{
2959	Elf_Scn *scn, *strscn;
2960	Elf_Data *data, *strdata;
2961	GElf_Shdr shdr;
2962	ulong_t i;
2963
2964	scn = NULL;
2965	while ((scn = elf_nextscn(elf, scn)) != NULL) {
2966		if (gelf_getshdr(scn, &shdr) == NULL) {
2967			(void) snprintf(errmsg, errlen,
2968			    "failed to get section header: %s\n",
2969			    elf_errmsg(elf_errno()));
2970			return (EINVAL);
2971		}
2972
2973		if (shdr.sh_type == SHT_SYMTAB)
2974			break;
2975	}
2976
2977	if (scn == NULL)
2978		return (0);
2979
2980	if ((strscn = elf_getscn(elf, shdr.sh_link)) == NULL) {
2981		(void) snprintf(errmsg, errlen,
2982		    "failed to get str section: %s\n",
2983		    elf_errmsg(elf_errno()));
2984		return (EINVAL);
2985	}
2986
2987	if ((data = elf_getdata(scn, NULL)) == NULL) {
2988		(void) snprintf(errmsg, errlen, "failed to read section: %s\n",
2989		    elf_errmsg(elf_errno()));
2990		return (EINVAL);
2991	}
2992
2993	if ((strdata = elf_getdata(strscn, NULL)) == NULL) {
2994		(void) snprintf(errmsg, errlen,
2995		    "failed to read string table: %s\n",
2996		    elf_errmsg(elf_errno()));
2997		return (EINVAL);
2998	}
2999
3000	for (i = 0; i < shdr.sh_size / shdr.sh_entsize; i++) {
3001		GElf_Sym sym;
3002		const char *file;
3003		size_t len;
3004
3005		if (gelf_getsym(data, i, &sym) == NULL) {
3006			(void) snprintf(errmsg, errlen,
3007			    "failed to read sym %lu: %s\n",
3008			    i, elf_errmsg(elf_errno()));
3009			return (EINVAL);
3010		}
3011
3012		if (GELF_ST_TYPE(sym.st_info) != STT_FILE)
3013			continue;
3014
3015		file = (const char *)((uintptr_t)strdata->d_buf + sym.st_name);
3016		len = strlen(file);
3017		if (len < 2 || strncmp(".c", &file[len - 2], 2) != 0)
3018			continue;
3019
3020		if (!c_source_has_debug(file, cus, nr_cus)) {
3021			(void) snprintf(errmsg, errlen,
3022			    "file %s is missing debug info\n", file);
3023			return (ECTF_CONVNODEBUG);
3024		}
3025	}
3026
3027	return (0);
3028}
3029
3030int
3031ctf_dwarf_convert(int fd, Elf *elf, uint_t nthrs, uint_t flags,
3032    ctf_file_t **fpp, char *errbuf, size_t errlen)
3033{
3034	int err, ret, ndies, i;
3035	Dwarf_Debug dw;
3036	Dwarf_Error derr;
3037	ctf_cu_t *cdies = NULL, *cup;
3038	workq_t *wqp = NULL;
3039
3040	*fpp = NULL;
3041
3042	ret = dwarf_elf_init(elf, DW_DLC_READ, NULL, NULL, &dw, &derr);
3043	if (ret != DW_DLV_OK) {
3044		if (ret == DW_DLV_NO_ENTRY ||
3045		    dwarf_errno(derr) == DW_DLE_DEBUG_INFO_NULL) {
3046			(void) snprintf(errbuf, errlen,
3047			    "file does not contain DWARF data\n");
3048			return (ECTF_CONVNODEBUG);
3049		}
3050
3051		(void) snprintf(errbuf, errlen,
3052		    "dwarf_elf_init() failed: %s\n", dwarf_errmsg(derr));
3053		return (ECTF_CONVBKERR);
3054	}
3055
3056	/*
3057	 * Iterate over all of the compilation units and create a ctf_cu_t for
3058	 * each of them.  This is used to determine if we have zero, one, or
3059	 * multiple dies to convert. If we have zero, that's an error. If
3060	 * there's only one die, that's the simple case.  No merge needed and
3061	 * only a single Dwarf_Debug as well.
3062	 */
3063	ndies = 0;
3064	err = ctf_dwarf_count_dies(dw, &derr, &ndies, errbuf, errlen);
3065
3066	ctf_dprintf("found %d DWARF CUs\n", ndies);
3067
3068	if (ndies == 0) {
3069		(void) snprintf(errbuf, errlen,
3070		    "file does not contain DWARF data\n");
3071		return (ECTF_CONVNODEBUG);
3072	}
3073
3074	(void) dwarf_finish(dw, &derr);
3075	cdies = ctf_alloc(sizeof (ctf_cu_t) * ndies);
3076	if (cdies == NULL) {
3077		return (ENOMEM);
3078	}
3079
3080	bzero(cdies, sizeof (ctf_cu_t) * ndies);
3081
3082	for (i = 0; i < ndies; i++) {
3083		cup = &cdies[i];
3084		ret = dwarf_elf_init(elf, DW_DLC_READ, NULL, NULL,
3085		    &cup->cu_dwarf, &derr);
3086		if (ret != 0) {
3087			ctf_free(cdies, sizeof (ctf_cu_t) * ndies);
3088			(void) snprintf(errbuf, errlen,
3089			    "failed to initialize DWARF: %s\n",
3090			    dwarf_errmsg(derr));
3091			return (ECTF_CONVBKERR);
3092		}
3093
3094		err = ctf_dwarf_init_die(fd, elf, cup, i, errbuf, errlen);
3095		if (err != 0)
3096			goto out;
3097
3098		cup->cu_doweaks = ndies > 1 ? B_FALSE : B_TRUE;
3099	}
3100
3101	if (!(flags & CTF_ALLOW_MISSING_DEBUG) &&
3102	    (err = ctf_dwarf_check_missing(cdies, ndies,
3103	    elf, errbuf, errlen)) != 0)
3104		goto out;
3105
3106	/*
3107	 * If we only have one compilation unit, there's no reason to use
3108	 * multiple threads, even if the user requested them. After all, they
3109	 * just gave us an upper bound.
3110	 */
3111	if (ndies == 1)
3112		nthrs = 1;
3113
3114	if (workq_init(&wqp, nthrs) == -1) {
3115		err = errno;
3116		goto out;
3117	}
3118
3119	for (i = 0; i < ndies; i++) {
3120		cup = &cdies[i];
3121		ctf_dprintf("adding cu %s: %p, %x %x\n", cup->cu_name,
3122		    cup->cu_cu, cup->cu_cuoff, cup->cu_maxoff);
3123		if (workq_add(wqp, cup) == -1) {
3124			err = errno;
3125			goto out;
3126		}
3127	}
3128
3129	ret = workq_work(wqp, ctf_dwarf_convert_one, NULL, &err);
3130	if (ret == WORKQ_ERROR) {
3131		err = errno;
3132		goto out;
3133	} else if (ret == WORKQ_UERROR) {
3134		ctf_dprintf("internal convert failed: %s\n",
3135		    ctf_errmsg(err));
3136		goto out;
3137	}
3138
3139	ctf_dprintf("Determining next phase: have %d CUs\n", ndies);
3140	if (ndies != 1) {
3141		ctf_merge_t *cmp;
3142
3143		cmp = ctf_merge_init(fd, &err);
3144		if (cmp == NULL)
3145			goto out;
3146
3147		ctf_dprintf("setting threads\n");
3148		if ((err = ctf_merge_set_nthreads(cmp, nthrs)) != 0) {
3149			ctf_merge_fini(cmp);
3150			goto out;
3151		}
3152
3153		for (i = 0; i < ndies; i++) {
3154			cup = &cdies[i];
3155			if ((err = ctf_merge_add(cmp, cup->cu_ctfp)) != 0) {
3156				ctf_merge_fini(cmp);
3157				goto out;
3158			}
3159		}
3160
3161		ctf_dprintf("performing merge\n");
3162		err = ctf_merge_merge(cmp, fpp);
3163		if (err != 0) {
3164			ctf_dprintf("failed merge!\n");
3165			*fpp = NULL;
3166			ctf_merge_fini(cmp);
3167			goto out;
3168		}
3169		ctf_merge_fini(cmp);
3170		err = 0;
3171		ctf_dprintf("successfully converted!\n");
3172	} else {
3173		err = 0;
3174		*fpp = cdies->cu_ctfp;
3175		cdies->cu_ctfp = NULL;
3176		ctf_dprintf("successfully converted!\n");
3177	}
3178
3179out:
3180	workq_fini(wqp);
3181	ctf_dwarf_free_dies(cdies, ndies);
3182	return (err);
3183}
3184