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