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