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.
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.
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]
22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
27 * DWARF to tdata conversion
29 * For the most part, conversion is straightforward, proceeding in two passes.
30 * On the first pass, we iterate through every die, creating new type nodes as
31 * necessary. Referenced tdesc_t's are created in an uninitialized state, thus
32 * allowing type reference pointers to be filled in. If the tdesc_t
33 * corresponding to a given die can be completely filled out (sizes and offsets
34 * calculated, and so forth) without using any referenced types, the tdesc_t is
35 * marked as resolved. Consider an array type. If the type corresponding to
36 * the array contents has not yet been processed, we will create a blank tdesc
37 * for the contents type (only the type ID will be filled in, relying upon the
38 * later portion of the first pass to encounter and complete the referenced
39 * type). We will then attempt to determine the size of the array. If the
40 * array has a byte size attribute, we will have completely characterized the
41 * array type, and will be able to mark it as resolved. The lack of a byte
42 * size attribute, on the other hand, will prevent us from fully resolving the
43 * type, as the size will only be calculable with reference to the contents
44 * type, which has not, as yet, been encountered. The array type will thus be
45 * left without the resolved flag, and the first pass will continue.
47 * When we begin the second pass, we will have created tdesc_t nodes for every
48 * type in the section. We will traverse the tree, from the iidescs down,
49 * processing each unresolved node. As the referenced nodes will have been
50 * populated, the array type used in our example above will be able to use the
51 * size of the referenced types (if available) to determine its own type. The
52 * traversal will be repeated until all types have been resolved or we have
53 * failed to make progress. When all tdescs have been resolved, the conversion
56 * There are, as always, a few special cases that are handled during the first
59 * 1. Empty enums - GCC will occasionally emit an enum without any members.
60 * Later on in the file, it will emit the same enum type, though this time
61 * with the full complement of members. All references to the memberless
62 * enum need to be redirected to the full definition. During the first
63 * pass, each enum is entered in dm_enumhash, along with a pointer to its
64 * corresponding tdesc_t. If, during the second pass, we encounter a
65 * memberless enum, we use the hash to locate the full definition. All
66 * tdescs referencing the empty enum are then redirected.
68 * 2. Forward declarations - If the compiler sees a forward declaration for
69 * a structure, followed by the definition of that structure, it will emit
70 * DWARF data for both the forward declaration and the definition. We need
71 * to resolve the forward declarations when possible, by redirecting
72 * forward-referencing tdescs to the actual struct/union definitions. This
73 * redirection is done completely within the first pass. We begin by
74 * recording all forward declarations in dw_fwdhash. When we define a
75 * structure, we check to see if there have been any corresponding forward
76 * declarations. If so, we redirect the tdescs which referenced the forward
77 * declarations to the structure or union definition.
79 * XXX see if a post traverser will allow the elimination of repeated pass 2
93 #include "ctf_headers.h"
99 /* The version of DWARF which we support. */
100 #define DWARF_VERSION 2
103 * We need to define a couple of our own intrinsics, to smooth out some of the
104 * differences between the GCC and DevPro DWARF emitters. See the referenced
105 * routines and the special cases in the file comment for more details.
107 * Type IDs are 32 bits wide. We're going to use the top of that field to
108 * indicate types that we've created ourselves.
110 #define TID_FILEMAX 0x3fffffff /* highest tid from file */
111 #define TID_VOID 0x40000001 /* see die_void() */
112 #define TID_LONG 0x40000002 /* see die_array() */
114 #define TID_MFGTID_BASE 0x40000003 /* first mfg'd tid */
117 * To reduce the staggering amount of error-handling code that would otherwise
118 * be required, the attribute-retrieval routines handle most of their own
119 * errors. If the following flag is supplied as the value of the `req'
120 * argument, they will also handle the absence of a requested attribute by
121 * terminating the program.
123 #define DW_ATTR_REQ 1
125 #define TDESC_HASH_BUCKETS 511
127 typedef struct dwarf {
128 Dwarf_Debug dw_dw; /* for libdwarf */
129 Dwarf_Error dw_err; /* for libdwarf */
130 Dwarf_Off dw_maxoff; /* highest legal offset in this cu */
131 tdata_t *dw_td; /* root of the tdesc/iidesc tree */
132 hash_t *dw_tidhash; /* hash of tdescs by t_id */
133 hash_t *dw_fwdhash; /* hash of fwd decls by name */
134 hash_t *dw_enumhash; /* hash of memberless enums by name */
135 tdesc_t *dw_void; /* manufactured void type */
136 tdesc_t *dw_long; /* manufactured long type for arrays */
137 size_t dw_ptrsz; /* size of a pointer in this file */
138 tid_t dw_mfgtid_last; /* last mfg'd type ID used */
139 uint_t dw_nunres; /* count of unresolved types */
140 char *dw_cuname; /* name of compilation unit */
143 static void die_create_one(dwarf_t *, Dwarf_Die);
144 static void die_create(dwarf_t *, Dwarf_Die);
147 mfgtid_next(dwarf_t *dw)
149 return (++dw->dw_mfgtid_last);
153 tdesc_add(dwarf_t *dw, tdesc_t *tdp)
155 hash_add(dw->dw_tidhash, tdp);
159 tdesc_lookup(dwarf_t *dw, int tid)
166 if (hash_find(dw->dw_tidhash, &tmpl, &tdp))
173 * Resolve a tdesc down to a node which should have a size. Returns the size,
174 * zero if the size hasn't yet been determined.
177 tdesc_size(tdesc_t *tdp)
180 switch (tdp->t_type) {
188 return (tdp->t_size);
200 case 0: /* not yet defined */
204 terminate("tdp %u: tdesc_size on unknown type %d\n",
205 tdp->t_id, tdp->t_type);
211 tdesc_bitsize(tdesc_t *tdp)
214 switch (tdp->t_type) {
216 return (tdp->t_intr->intr_nbits);
224 return (tdp->t_size * NBBY);
236 case 0: /* not yet defined */
240 terminate("tdp %u: tdesc_bitsize on unknown type %d\n",
241 tdp->t_id, tdp->t_type);
247 tdesc_basetype(tdesc_t *tdp)
250 switch (tdp->t_type) {
257 case 0: /* not yet defined */
266 die_off(dwarf_t *dw, Dwarf_Die die)
270 if (dwarf_dieoffset(die, &off, &dw->dw_err) == DW_DLV_OK)
273 terminate("failed to get offset for die: %s\n",
274 dwarf_errmsg(&dw->dw_err));
280 die_sibling(dwarf_t *dw, Dwarf_Die die)
285 if ((rc = dwarf_siblingof(dw->dw_dw, die, &sib, &dw->dw_err)) ==
288 else if (rc == DW_DLV_NO_ENTRY)
291 terminate("die %llu: failed to find type sibling: %s\n",
292 die_off(dw, die), dwarf_errmsg(&dw->dw_err));
298 die_child(dwarf_t *dw, Dwarf_Die die)
303 if ((rc = dwarf_child(die, &child, &dw->dw_err)) == DW_DLV_OK)
305 else if (rc == DW_DLV_NO_ENTRY)
308 terminate("die %llu: failed to find type child: %s\n",
309 die_off(dw, die), dwarf_errmsg(&dw->dw_err));
315 die_tag(dwarf_t *dw, Dwarf_Die die)
319 if (dwarf_tag(die, &tag, &dw->dw_err) == DW_DLV_OK)
322 terminate("die %llu: failed to get tag for type: %s\n",
323 die_off(dw, die), dwarf_errmsg(&dw->dw_err));
328 static Dwarf_Attribute
329 die_attr(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, int req)
331 Dwarf_Attribute attr;
334 if ((rc = dwarf_attr(die, name, &attr, &dw->dw_err)) == DW_DLV_OK) {
336 } else if (rc == DW_DLV_NO_ENTRY) {
338 terminate("die %llu: no attr 0x%x\n", die_off(dw, die),
345 terminate("die %llu: failed to get attribute for type: %s\n",
346 die_off(dw, die), dwarf_errmsg(&dw->dw_err));
352 die_signed(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, Dwarf_Signed *valp,
356 if (dwarf_attrval_signed(die, name, valp, &dw->dw_err) != DWARF_E_NONE) {
358 terminate("die %llu: failed to get signed: %s\n",
359 die_off(dw, die), dwarf_errmsg(&dw->dw_err));
367 die_unsigned(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, Dwarf_Unsigned *valp,
371 if (dwarf_attrval_unsigned(die, name, valp, &dw->dw_err) != DWARF_E_NONE) {
373 terminate("die %llu: failed to get unsigned: %s\n",
374 die_off(dw, die), dwarf_errmsg(&dw->dw_err));
382 die_bool(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, Dwarf_Bool *valp, int req)
386 if (dwarf_attrval_flag(die, name, valp, &dw->dw_err) != DWARF_E_NONE) {
388 terminate("die %llu: failed to get flag: %s\n",
389 die_off(dw, die), dwarf_errmsg(&dw->dw_err));
397 die_string(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, char **strp, int req)
399 const char *str = NULL;
401 if (dwarf_attrval_string(die, name, &str, &dw->dw_err) != DWARF_E_NONE ||
404 terminate("die %llu: failed to get string: %s\n",
405 die_off(dw, die), dwarf_errmsg(&dw->dw_err));
410 *strp = xstrdup(str);
416 die_attr_ref(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name)
420 if (dwarf_attrval_unsigned(die, name, &off, &dw->dw_err) != DWARF_E_NONE) {
421 terminate("die %llu: failed to get ref: %s\n",
422 die_off(dw, die), dwarf_errmsg(&dw->dw_err));
429 die_name(dwarf_t *dw, Dwarf_Die die)
433 (void) die_string(dw, die, DW_AT_name, &str, 0);
439 die_isdecl(dwarf_t *dw, Dwarf_Die die)
443 return (die_bool(dw, die, DW_AT_declaration, &val, 0) && val);
447 die_isglobal(dwarf_t *dw, Dwarf_Die die)
453 * Some compilers (gcc) use DW_AT_external to indicate function
454 * visibility. Others (Sun) use DW_AT_visibility.
456 if (die_signed(dw, die, DW_AT_visibility, &vis, 0))
457 return (vis == DW_VIS_exported);
459 return (die_bool(dw, die, DW_AT_external, &ext, 0) && ext);
463 die_add(dwarf_t *dw, Dwarf_Off off)
465 tdesc_t *tdp = xcalloc(sizeof (tdesc_t));
475 die_lookup_pass1(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name)
477 Dwarf_Off ref = die_attr_ref(dw, die, name);
480 if ((tdp = tdesc_lookup(dw, ref)) != NULL)
483 return (die_add(dw, ref));
487 die_mem_offset(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name,
488 Dwarf_Unsigned *valp, int req __unused)
490 Dwarf_Locdesc *loc = NULL;
491 Dwarf_Signed locnum = 0;
495 if (name != DW_AT_data_member_location)
496 terminate("die %llu: can only process attribute "
497 "DW_AT_data_member_location\n", die_off(dw, die));
499 if ((at = die_attr(dw, die, name, 0)) == NULL)
502 if (dwarf_whatform(at, &form, &dw->dw_err) != DW_DLV_OK)
511 * GCC in base and Clang (3.3 or below) generates
512 * DW_AT_data_member_location attribute with DW_FORM_block*
513 * form. The attribute contains one DW_OP_plus_uconst
514 * operator. The member offset stores in the operand.
516 if (dwarf_locdesc(die, name, &loc, &locnum, &dw->dw_err) !=
519 if (locnum != 1 || loc->ld_s->lr_atom != DW_OP_plus_uconst) {
520 terminate("die %llu: cannot parse member offset\n",
523 *valp = loc->ld_s->lr_number;
532 * Clang 3.4 generates DW_AT_data_member_location attribute
533 * with DW_FORM_data* form (constant class). The attribute
534 * stores a contant value which is the member offset.
536 if (dwarf_attrval_unsigned(die, name, valp, &dw->dw_err) !=
542 terminate("die %llu: cannot parse member offset with form "
543 "%u\n", die_off(dw, die), form);
547 if (dwarf_locdesc_free(loc, &dw->dw_err) != DW_DLV_OK)
548 terminate("die %llu: cannot free location descriptor: %s\n",
549 die_off(dw, die), dwarf_errmsg(&dw->dw_err));
555 tdesc_intr_common(dwarf_t *dw, int tid, const char *name, size_t sz)
560 intr = xcalloc(sizeof (intr_t));
561 intr->intr_type = INTR_INT;
562 intr->intr_signed = 1;
563 intr->intr_nbits = sz * NBBY;
565 tdp = xcalloc(sizeof (tdesc_t));
566 tdp->t_name = xstrdup(name);
569 tdp->t_type = INTRINSIC;
571 tdp->t_flags = TDESC_F_RESOLVED;
579 * Manufacture a void type. Used for gcc-emitted stabs, where the lack of a
580 * type reference implies a reference to a void type. A void *, for example
581 * will be represented by a pointer die without a DW_AT_type. CTF requires
582 * that pointer nodes point to something, so we'll create a void for use as
583 * the target. Note that the DWARF data may already create a void type. Ours
584 * would then be a duplicate, but it'll be removed in the self-uniquification
585 * merge performed at the completion of DWARF->tdesc conversion.
588 tdesc_intr_void(dwarf_t *dw)
590 if (dw->dw_void == NULL)
591 dw->dw_void = tdesc_intr_common(dw, TID_VOID, "void", 0);
593 return (dw->dw_void);
597 tdesc_intr_long(dwarf_t *dw)
599 if (dw->dw_long == NULL) {
600 dw->dw_long = tdesc_intr_common(dw, TID_LONG, "long",
604 return (dw->dw_long);
608 * Used for creating bitfield types. We create a copy of an existing intrinsic,
609 * adjusting the size of the copy to match what the caller requested. The
610 * caller can then use the copy as the type for a bitfield structure member.
613 tdesc_intr_clone(dwarf_t *dw, tdesc_t *old, size_t bitsz)
615 tdesc_t *new = xcalloc(sizeof (tdesc_t));
617 if (!(old->t_flags & TDESC_F_RESOLVED)) {
618 terminate("tdp %u: attempt to make a bit field from an "
619 "unresolved type\n", old->t_id);
622 new->t_name = xstrdup(old->t_name);
623 new->t_size = old->t_size;
624 new->t_id = mfgtid_next(dw);
625 new->t_type = INTRINSIC;
626 new->t_flags = TDESC_F_RESOLVED;
628 new->t_intr = xcalloc(sizeof (intr_t));
629 bcopy(old->t_intr, new->t_intr, sizeof (intr_t));
630 new->t_intr->intr_nbits = bitsz;
638 tdesc_array_create(dwarf_t *dw, Dwarf_Die dim, tdesc_t *arrtdp,
643 tdesc_t *ctdp = NULL;
647 if ((dim2 = die_sibling(dw, dim)) == NULL) {
649 } else if (die_tag(dw, dim2) == DW_TAG_subrange_type) {
650 ctdp = xcalloc(sizeof (tdesc_t));
651 ctdp->t_id = mfgtid_next(dw);
652 debug(3, "die %llu: creating new type %u for sub-dimension\n",
653 die_off(dw, dim2), ctdp->t_id);
654 tdesc_array_create(dw, dim2, arrtdp, ctdp);
656 terminate("die %llu: unexpected non-subrange node in array\n",
660 dimtdp->t_type = ARRAY;
661 dimtdp->t_ardef = ar = xcalloc(sizeof (ardef_t));
664 * Array bounds can be signed or unsigned, but there are several kinds
665 * of signless forms (data1, data2, etc) that take their sign from the
666 * routine that is trying to interpret them. That is, data1 can be
667 * either signed or unsigned, depending on whether you use the signed or
668 * unsigned accessor function. GCC will use the signless forms to store
669 * unsigned values which have their high bit set, so we need to try to
670 * read them first as unsigned to get positive values. We could also
671 * try signed first, falling back to unsigned if we got a negative
674 if (die_unsigned(dw, dim, DW_AT_upper_bound, &uval, 0))
675 ar->ad_nelems = uval + 1;
676 else if (die_signed(dw, dim, DW_AT_upper_bound, &sval, 0))
677 ar->ad_nelems = sval + 1;
678 else if (die_unsigned(dw, dim, DW_AT_count, &uval, 0))
679 ar->ad_nelems = uval;
680 else if (die_signed(dw, dim, DW_AT_count, &sval, 0))
681 ar->ad_nelems = sval;
686 * Different compilers use different index types. Force the type to be
687 * a common, known value (long).
689 ar->ad_idxtype = tdesc_intr_long(dw);
690 ar->ad_contents = ctdp;
692 if (ar->ad_contents->t_size != 0) {
693 dimtdp->t_size = ar->ad_contents->t_size * ar->ad_nelems;
694 dimtdp->t_flags |= TDESC_F_RESOLVED;
699 * Create a tdesc from an array node. Some arrays will come with byte size
700 * attributes, and thus can be resolved immediately. Others don't, and will
701 * need to wait until the second pass for resolution.
704 die_array_create(dwarf_t *dw, Dwarf_Die arr, Dwarf_Off off, tdesc_t *tdp)
706 tdesc_t *arrtdp = die_lookup_pass1(dw, arr, DW_AT_type);
710 debug(3, "die %llu <%llx>: creating array\n", off, off);
712 if ((dim = die_child(dw, arr)) == NULL ||
713 die_tag(dw, dim) != DW_TAG_subrange_type)
714 terminate("die %llu: failed to retrieve array bounds\n", off);
716 tdesc_array_create(dw, dim, arrtdp, tdp);
718 if (die_unsigned(dw, arr, DW_AT_byte_size, &uval, 0)) {
722 /* Check for bogus gcc DW_AT_byte_size attribute */
723 if (uval == (unsigned)-1) {
724 printf("dwarf.c:%s() working around bogus -1 DW_AT_byte_size\n",
732 * Ensure that sub-dimensions have sizes too before marking
735 flags = TDESC_F_RESOLVED;
736 for (dimtdp = tdp->t_ardef->ad_contents;
737 dimtdp->t_type == ARRAY;
738 dimtdp = dimtdp->t_ardef->ad_contents) {
739 if (!(dimtdp->t_flags & TDESC_F_RESOLVED)) {
745 tdp->t_flags |= flags;
748 debug(3, "die %llu <%llx>: array nelems %u size %u\n", off, off,
749 tdp->t_ardef->ad_nelems, tdp->t_size);
754 die_array_resolve(tdesc_t *tdp, tdesc_t **tdpp __unused, void *private)
756 dwarf_t *dw = private;
759 if (tdp->t_flags & TDESC_F_RESOLVED)
762 debug(3, "trying to resolve array %d (cont %d)\n", tdp->t_id,
763 tdp->t_ardef->ad_contents->t_id);
765 if ((sz = tdesc_size(tdp->t_ardef->ad_contents)) == 0) {
766 debug(3, "unable to resolve array %s (%d) contents %d\n",
767 tdesc_name(tdp), tdp->t_id,
768 tdp->t_ardef->ad_contents->t_id);
774 tdp->t_size = sz * tdp->t_ardef->ad_nelems;
775 tdp->t_flags |= TDESC_F_RESOLVED;
777 debug(3, "resolved array %d: %u bytes\n", tdp->t_id, tdp->t_size);
784 die_array_failed(tdesc_t *tdp, tdesc_t **tdpp __unused, void *private __unused)
786 tdesc_t *cont = tdp->t_ardef->ad_contents;
788 if (tdp->t_flags & TDESC_F_RESOLVED)
791 fprintf(stderr, "Array %d: failed to size contents type %s (%d)\n",
792 tdp->t_id, tdesc_name(cont), cont->t_id);
798 * Most enums (those with members) will be resolved during this first pass.
799 * Others - those without members (see the file comment) - won't be, and will
800 * need to wait until the second pass when they can be matched with their full
804 die_enum_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
810 if (die_isdecl(dw, die)) {
811 tdp->t_type = FORWARD;
815 debug(3, "die %llu: creating enum\n", off);
819 (void) die_unsigned(dw, die, DW_AT_byte_size, &uval, DW_ATTR_REQ);
820 /* Check for bogus gcc DW_AT_byte_size attribute */
821 if (uval == (unsigned)-1) {
822 printf("dwarf.c:%s() working around bogus -1 DW_AT_byte_size\n",
828 if ((mem = die_child(dw, die)) != NULL) {
829 elist_t **elastp = &tdp->t_emem;
834 if (die_tag(dw, mem) != DW_TAG_enumerator) {
835 /* Nested type declaration */
836 die_create_one(dw, mem);
840 el = xcalloc(sizeof (elist_t));
841 el->el_name = die_name(dw, mem);
843 if (die_signed(dw, mem, DW_AT_const_value, &sval, 0)) {
844 el->el_number = sval;
845 } else if (die_unsigned(dw, mem, DW_AT_const_value,
847 el->el_number = uval;
849 terminate("die %llu: enum %llu: member without "
850 "value\n", off, die_off(dw, mem));
853 debug(3, "die %llu: enum %llu: created %s = %d\n", off,
854 die_off(dw, mem), el->el_name, el->el_number);
857 elastp = &el->el_next;
859 } while ((mem = die_sibling(dw, mem)) != NULL);
861 hash_add(dw->dw_enumhash, tdp);
863 tdp->t_flags |= TDESC_F_RESOLVED;
865 if (tdp->t_name != NULL) {
866 iidesc_t *ii = xcalloc(sizeof (iidesc_t));
867 ii->ii_type = II_SOU;
868 ii->ii_name = xstrdup(tdp->t_name);
871 iidesc_add(dw->dw_td->td_iihash, ii);
877 die_enum_match(void *arg1, void *arg2)
879 tdesc_t *tdp = arg1, **fullp = arg2;
881 if (tdp->t_emem != NULL) {
883 return (-1); /* stop the iteration */
891 die_enum_resolve(tdesc_t *tdp, tdesc_t **tdpp __unused, void *private)
893 dwarf_t *dw = private;
894 tdesc_t *full = NULL;
896 if (tdp->t_flags & TDESC_F_RESOLVED)
899 (void) hash_find_iter(dw->dw_enumhash, tdp, die_enum_match, &full);
902 * The answer to this one won't change from iteration to iteration,
906 terminate("tdp %u: enum %s has no members\n", tdp->t_id,
910 debug(3, "tdp %u: enum %s redirected to %u\n", tdp->t_id,
911 tdesc_name(tdp), full->t_id);
913 tdp->t_flags |= TDESC_F_RESOLVED;
919 die_fwd_map(void *arg1, void *arg2)
921 tdesc_t *fwd = arg1, *sou = arg2;
923 debug(3, "tdp %u: mapped forward %s to sou %u\n", fwd->t_id,
924 tdesc_name(fwd), sou->t_id);
931 * Structures and unions will never be resolved during the first pass, as we
932 * won't be able to fully determine the member sizes. The second pass, which
933 * have access to sizing information, will be able to complete the resolution.
936 die_sou_create(dwarf_t *dw, Dwarf_Die str, Dwarf_Off off, tdesc_t *tdp,
937 int type, const char *typename)
939 Dwarf_Unsigned sz, bitsz, bitoff, maxsz=0;
940 #if BYTE_ORDER == _LITTLE_ENDIAN
944 mlist_t *ml, **mlastp;
947 tdp->t_type = (die_isdecl(dw, str) ? FORWARD : type);
949 debug(3, "die %llu: creating %s %s\n", off,
950 (tdp->t_type == FORWARD ? "forward decl" : typename),
953 if (tdp->t_type == FORWARD) {
954 hash_add(dw->dw_fwdhash, tdp);
958 (void) hash_find_iter(dw->dw_fwdhash, tdp, die_fwd_map, tdp);
960 (void) die_unsigned(dw, str, DW_AT_byte_size, &sz, DW_ATTR_REQ);
964 * GCC allows empty SOUs as an extension.
966 if ((mem = die_child(dw, str)) == NULL) {
970 mlastp = &tdp->t_members;
973 Dwarf_Off memoff = die_off(dw, mem);
974 Dwarf_Half tag = die_tag(dw, mem);
975 Dwarf_Unsigned mloff;
977 if (tag != DW_TAG_member) {
978 /* Nested type declaration */
979 die_create_one(dw, mem);
983 debug(3, "die %llu: mem %llu: creating member\n", off, memoff);
985 ml = xcalloc(sizeof (mlist_t));
988 * This could be a GCC anon struct/union member, so we'll allow
989 * an empty name, even though nothing can really handle them
990 * properly. Note that some versions of GCC miss out debug
991 * info for anon structs, though recent versions are fixed (gcc
994 if ((ml->ml_name = die_name(dw, mem)) == NULL)
997 ml->ml_type = die_lookup_pass1(dw, mem, DW_AT_type);
998 debug(3, "die_sou_create(): ml_type = %p t_id = %d\n",
999 ml->ml_type, ml->ml_type->t_id);
1001 if (die_mem_offset(dw, mem, DW_AT_data_member_location,
1003 debug(3, "die %llu: got mloff %llx\n", off,
1004 (u_longlong_t)mloff);
1005 ml->ml_offset = mloff * 8;
1008 if (die_unsigned(dw, mem, DW_AT_bit_size, &bitsz, 0))
1009 ml->ml_size = bitsz;
1011 ml->ml_size = tdesc_bitsize(ml->ml_type);
1013 if (die_unsigned(dw, mem, DW_AT_bit_offset, &bitoff, 0)) {
1014 #if BYTE_ORDER == _BIG_ENDIAN
1015 ml->ml_offset += bitoff;
1018 * Note that Clang 3.4 will sometimes generate
1019 * member DIE before generating the DIE for the
1020 * member's type. The code can not handle this
1021 * properly so that tdesc_bitsize(ml->ml_type) will
1022 * return 0 because ml->ml_type is unknown. As a
1023 * result, a wrong member offset will be calculated.
1024 * To workaround this, we can instead try to
1025 * retrieve the value of DW_AT_byte_size attribute
1026 * which stores the byte size of the space occupied
1027 * by the type. If this attribute exists, its value
1028 * should equal to tdesc_bitsize(ml->ml_type)/NBBY.
1030 if (die_unsigned(dw, mem, DW_AT_byte_size, &bysz, 0) &&
1032 ml->ml_offset += bysz * NBBY - bitoff -
1035 ml->ml_offset += tdesc_bitsize(ml->ml_type) -
1036 bitoff - ml->ml_size;
1040 debug(3, "die %llu: mem %llu: created \"%s\" (off %u sz %u)\n",
1041 off, memoff, ml->ml_name, ml->ml_offset, ml->ml_size);
1044 mlastp = &ml->ml_next;
1046 /* Find the size of the largest member to work around a gcc
1047 * bug. See GCC Bugzilla 35998.
1049 if (maxsz < ml->ml_size)
1050 maxsz = ml->ml_size;
1052 } while ((mem = die_sibling(dw, mem)) != NULL);
1054 /* See if we got a bogus DW_AT_byte_size. GCC will sometimes
1057 if (sz == (unsigned)-1) {
1058 printf("dwarf.c:%s() working around bogus -1 DW_AT_byte_size\n",
1060 tdp->t_size = maxsz / 8; /* maxsz is in bits, t_size is bytes */
1064 * GCC will attempt to eliminate unused types, thus decreasing the
1065 * size of the emitted dwarf. That is, if you declare a foo_t in your
1066 * header, include said header in your source file, and neglect to
1067 * actually use (directly or indirectly) the foo_t in the source file,
1068 * the foo_t won't make it into the emitted DWARF. So, at least, goes
1071 * Occasionally, it'll emit the DW_TAG_structure_type for the foo_t,
1072 * and then neglect to emit the members. Strangely, the loner struct
1073 * tag will always be followed by a proper nested declaration of
1074 * something else. This is clearly a bug, but we're not going to have
1075 * time to get it fixed before this goo goes back, so we'll have to work
1076 * around it. If we see a no-membered struct with a nested declaration
1077 * (i.e. die_child of the struct tag won't be null), we'll ignore it.
1078 * Being paranoid, we won't simply remove it from the hash. Instead,
1079 * we'll decline to create an iidesc for it, thus ensuring that this
1080 * type won't make it into the output file. To be safe, we'll also
1083 if (tdp->t_members == NULL) {
1084 const char *old = tdesc_name(tdp);
1085 size_t newsz = 7 + strlen(old) + 1;
1086 char *new = xmalloc(newsz);
1087 (void) snprintf(new, newsz, "orphan %s", old);
1089 debug(3, "die %llu: worked around %s %s\n", off, typename, old);
1091 if (tdp->t_name != NULL)
1098 if (tdp->t_name != NULL) {
1099 ii = xcalloc(sizeof (iidesc_t));
1100 ii->ii_type = II_SOU;
1101 ii->ii_name = xstrdup(tdp->t_name);
1104 iidesc_add(dw->dw_td->td_iihash, ii);
1109 die_struct_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1111 die_sou_create(dw, die, off, tdp, STRUCT, "struct");
1115 die_union_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1117 die_sou_create(dw, die, off, tdp, UNION, "union");
1122 die_sou_resolve(tdesc_t *tdp, tdesc_t **tdpp __unused, void *private)
1124 dwarf_t *dw = private;
1128 if (tdp->t_flags & TDESC_F_RESOLVED)
1131 debug(3, "resolving sou %s\n", tdesc_name(tdp));
1133 for (ml = tdp->t_members; ml != NULL; ml = ml->ml_next) {
1134 if (ml->ml_size == 0) {
1135 mt = tdesc_basetype(ml->ml_type);
1137 if ((ml->ml_size = tdesc_bitsize(mt)) != 0)
1141 * For empty members, or GCC/C99 flexible array
1142 * members, a size of 0 is correct.
1144 if (mt->t_members == NULL)
1146 if (mt->t_type == ARRAY && mt->t_ardef->ad_nelems == 0)
1153 if ((mt = tdesc_basetype(ml->ml_type)) == NULL) {
1158 if (ml->ml_size != 0 && mt->t_type == INTRINSIC &&
1159 mt->t_intr->intr_nbits != (int)ml->ml_size) {
1161 * This member is a bitfield, and needs to reference
1162 * an intrinsic type with the same width. If the
1163 * currently-referenced type isn't of the same width,
1164 * we'll copy it, adjusting the width of the copy to
1165 * the size we'd like.
1167 debug(3, "tdp %u: creating bitfield for %d bits\n",
1168 tdp->t_id, ml->ml_size);
1170 ml->ml_type = tdesc_intr_clone(dw, mt, ml->ml_size);
1174 tdp->t_flags |= TDESC_F_RESOLVED;
1181 die_sou_failed(tdesc_t *tdp, tdesc_t **tdpp __unused, void *private __unused)
1183 const char *typename = (tdp->t_type == STRUCT ? "struct" : "union");
1186 if (tdp->t_flags & TDESC_F_RESOLVED)
1189 for (ml = tdp->t_members; ml != NULL; ml = ml->ml_next) {
1190 if (ml->ml_size == 0) {
1191 fprintf(stderr, "%s %d <%x>: failed to size member \"%s\" "
1192 "of type %s (%d <%x>)\n", typename, tdp->t_id,
1194 ml->ml_name, tdesc_name(ml->ml_type),
1195 ml->ml_type->t_id, ml->ml_type->t_id);
1203 die_funcptr_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1205 Dwarf_Attribute attr;
1211 debug(3, "die %llu <%llx>: creating function pointer\n", off, off);
1214 * We'll begin by processing any type definition nodes that may be
1215 * lurking underneath this one.
1217 for (arg = die_child(dw, die); arg != NULL;
1218 arg = die_sibling(dw, arg)) {
1219 if ((tag = die_tag(dw, arg)) != DW_TAG_formal_parameter &&
1220 tag != DW_TAG_unspecified_parameters) {
1221 /* Nested type declaration */
1222 die_create_one(dw, arg);
1226 if (die_isdecl(dw, die)) {
1228 * This is a prototype. We don't add prototypes to the
1229 * tree, so we're going to drop the tdesc. Unfortunately,
1230 * it has already been added to the tree. Nobody will reference
1231 * it, though, and it will be leaked.
1236 fn = xcalloc(sizeof (fndef_t));
1238 tdp->t_type = FUNCTION;
1240 if ((attr = die_attr(dw, die, DW_AT_type, 0)) != NULL) {
1241 fn->fn_ret = die_lookup_pass1(dw, die, DW_AT_type);
1243 fn->fn_ret = tdesc_intr_void(dw);
1247 * Count the arguments to the function, then read them in.
1249 for (fn->fn_nargs = 0, arg = die_child(dw, die); arg != NULL;
1250 arg = die_sibling(dw, arg)) {
1251 if ((tag = die_tag(dw, arg)) == DW_TAG_formal_parameter)
1253 else if (tag == DW_TAG_unspecified_parameters &&
1258 if (fn->fn_nargs != 0) {
1259 debug(3, "die %llu: adding %d argument%s\n", off, fn->fn_nargs,
1260 (fn->fn_nargs > 1 ? "s" : ""));
1262 fn->fn_args = xcalloc(sizeof (tdesc_t *) * fn->fn_nargs);
1263 for (i = 0, arg = die_child(dw, die);
1264 arg != NULL && i < (int) fn->fn_nargs;
1265 arg = die_sibling(dw, arg)) {
1266 if (die_tag(dw, arg) != DW_TAG_formal_parameter)
1269 fn->fn_args[i++] = die_lookup_pass1(dw, arg,
1275 tdp->t_flags |= TDESC_F_RESOLVED;
1279 * GCC and DevPro use different names for the base types. While the terms are
1280 * the same, they are arranged in a different order. Some terms, such as int,
1281 * are implied in one, and explicitly named in the other. Given a base type
1282 * as input, this routine will return a common name, along with an intr_t
1283 * that reflects said name.
1286 die_base_name_parse(const char *name, char **newp)
1291 int nlong = 0, nshort = 0, nchar = 0, nint = 0;
1296 if (strlen(name) > sizeof (buf) - 1)
1297 terminate("base type name \"%s\" is too long\n", name);
1299 strncpy(buf, name, sizeof (buf));
1301 for (c = strtok(buf, " "); c != NULL; c = strtok(NULL, " ")) {
1302 if (strcmp(c, "signed") == 0)
1304 else if (strcmp(c, "unsigned") == 0)
1306 else if (strcmp(c, "long") == 0)
1308 else if (strcmp(c, "char") == 0) {
1311 } else if (strcmp(c, "short") == 0)
1313 else if (strcmp(c, "int") == 0)
1317 * If we don't recognize any of the tokens, we'll tell
1318 * the caller to fall back to the dwarf-provided
1319 * encoding information.
1325 if (nchar > 1 || nshort > 1 || nint > 1 || nlong > 2)
1329 if (nlong > 0 || nshort > 0 || nint > 0)
1334 } else if (nshort > 0) {
1340 } else if (nlong > 0) {
1347 intr = xcalloc(sizeof (intr_t));
1348 intr->intr_type = INTR_INT;
1349 intr->intr_signed = sign;
1350 intr->intr_iformat = fmt;
1352 snprintf(buf, sizeof (buf), "%s%s%s",
1353 (sign ? "" : "unsigned "),
1354 (nlong > 1 ? "long " : ""),
1357 *newp = xstrdup(buf);
1361 typedef struct fp_size_map {
1362 size_t fsm_typesz[2]; /* size of {32,64} type */
1363 uint_t fsm_enc[3]; /* CTF_FP_* for {bare,cplx,imagry} type */
1366 static const fp_size_map_t fp_encodings[] = {
1367 { { 4, 4 }, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } },
1368 { { 8, 8 }, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } },
1370 { { 16, 16 }, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } },
1372 { { 12, 16 }, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } },
1374 { { 0, 0 }, { 0, 0, 0 } }
1378 die_base_type2enc(dwarf_t *dw, Dwarf_Off off, Dwarf_Signed enc, size_t sz)
1380 const fp_size_map_t *map = fp_encodings;
1381 uint_t szidx = dw->dw_ptrsz == sizeof (uint64_t);
1382 uint_t mult = 1, col = 0;
1384 if (enc == DW_ATE_complex_float) {
1387 } else if (enc == DW_ATE_imaginary_float
1389 || enc == DW_ATE_SUN_imaginary_float
1394 while (map->fsm_typesz[szidx] != 0) {
1395 if (map->fsm_typesz[szidx] * mult == sz)
1396 return (map->fsm_enc[col]);
1400 terminate("die %llu: unrecognized real type size %u\n", off, sz);
1406 die_base_from_dwarf(dwarf_t *dw, Dwarf_Die base, Dwarf_Off off, size_t sz)
1408 intr_t *intr = xcalloc(sizeof (intr_t));
1411 (void) die_signed(dw, base, DW_AT_encoding, &enc, DW_ATTR_REQ);
1414 case DW_ATE_unsigned:
1415 case DW_ATE_address:
1416 intr->intr_type = INTR_INT;
1418 case DW_ATE_unsigned_char:
1419 intr->intr_type = INTR_INT;
1420 intr->intr_iformat = 'c';
1423 intr->intr_type = INTR_INT;
1424 intr->intr_signed = 1;
1426 case DW_ATE_signed_char:
1427 intr->intr_type = INTR_INT;
1428 intr->intr_signed = 1;
1429 intr->intr_iformat = 'c';
1431 case DW_ATE_boolean:
1432 intr->intr_type = INTR_INT;
1433 intr->intr_signed = 1;
1434 intr->intr_iformat = 'b';
1437 case DW_ATE_complex_float:
1438 case DW_ATE_imaginary_float:
1440 case DW_ATE_SUN_imaginary_float:
1441 case DW_ATE_SUN_interval_float:
1443 intr->intr_type = INTR_REAL;
1444 intr->intr_signed = 1;
1445 intr->intr_fformat = die_base_type2enc(dw, off, enc, sz);
1448 terminate("die %llu: unknown base type encoding 0x%llx\n",
1456 die_base_create(dwarf_t *dw, Dwarf_Die base, Dwarf_Off off, tdesc_t *tdp)
1462 debug(3, "die %llu: creating base type\n", off);
1465 * The compilers have their own clever (internally inconsistent) ideas
1466 * as to what base types should look like. Some times gcc will, for
1467 * example, use DW_ATE_signed_char for char. Other times, however, it
1468 * will use DW_ATE_signed. Needless to say, this causes some problems
1469 * down the road, particularly with merging. We do, however, use the
1470 * DWARF idea of type sizes, as this allows us to avoid caring about
1473 (void) die_unsigned(dw, base, DW_AT_byte_size, &sz, DW_ATTR_REQ);
1475 /* Check for bogus gcc DW_AT_byte_size attribute */
1476 if (sz == (unsigned)-1) {
1477 printf("dwarf.c:%s() working around bogus -1 DW_AT_byte_size\n",
1482 if (tdp->t_name == NULL)
1483 terminate("die %llu: base type without name\n", off);
1485 /* XXX make a name parser for float too */
1486 if ((intr = die_base_name_parse(tdp->t_name, &new)) != NULL) {
1487 /* Found it. We'll use the parsed version */
1488 debug(3, "die %llu: name \"%s\" remapped to \"%s\"\n", off,
1489 tdesc_name(tdp), new);
1495 * We didn't recognize the type, so we'll create an intr_t
1496 * based on the DWARF data.
1498 debug(3, "die %llu: using dwarf data for base \"%s\"\n", off,
1501 intr = die_base_from_dwarf(dw, base, off, sz);
1504 intr->intr_nbits = sz * 8;
1506 tdp->t_type = INTRINSIC;
1510 tdp->t_flags |= TDESC_F_RESOLVED;
1514 die_through_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp,
1515 int type, const char *typename)
1517 Dwarf_Attribute attr;
1519 debug(3, "die %llu <%llx>: creating %s type %d\n", off, off, typename, type);
1523 if ((attr = die_attr(dw, die, DW_AT_type, 0)) != NULL) {
1524 tdp->t_tdesc = die_lookup_pass1(dw, die, DW_AT_type);
1526 tdp->t_tdesc = tdesc_intr_void(dw);
1529 if (type == POINTER)
1530 tdp->t_size = dw->dw_ptrsz;
1532 tdp->t_flags |= TDESC_F_RESOLVED;
1534 if (type == TYPEDEF) {
1535 iidesc_t *ii = xcalloc(sizeof (iidesc_t));
1536 ii->ii_type = II_TYPE;
1537 ii->ii_name = xstrdup(tdp->t_name);
1540 iidesc_add(dw->dw_td->td_iihash, ii);
1545 die_typedef_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1547 die_through_create(dw, die, off, tdp, TYPEDEF, "typedef");
1551 die_const_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1553 die_through_create(dw, die, off, tdp, CONST, "const");
1557 die_pointer_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1559 die_through_create(dw, die, off, tdp, POINTER, "pointer");
1563 die_restrict_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1565 die_through_create(dw, die, off, tdp, RESTRICT, "restrict");
1569 die_volatile_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp)
1571 die_through_create(dw, die, off, tdp, VOLATILE, "volatile");
1576 die_function_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp __unused)
1583 debug(3, "die %llu <%llx>: creating function definition\n", off, off);
1586 * We'll begin by processing any type definition nodes that may be
1587 * lurking underneath this one.
1589 for (arg = die_child(dw, die); arg != NULL;
1590 arg = die_sibling(dw, arg)) {
1591 if ((tag = die_tag(dw, arg)) != DW_TAG_formal_parameter &&
1592 tag != DW_TAG_variable) {
1593 /* Nested type declaration */
1594 die_create_one(dw, arg);
1598 if (die_isdecl(dw, die) || (name = die_name(dw, die)) == NULL) {
1600 * We process neither prototypes nor subprograms without
1606 ii = xcalloc(sizeof (iidesc_t));
1607 ii->ii_type = die_isglobal(dw, die) ? II_GFUN : II_SFUN;
1609 if (ii->ii_type == II_SFUN)
1610 ii->ii_owner = xstrdup(dw->dw_cuname);
1612 debug(3, "die %llu: function %s is %s\n", off, ii->ii_name,
1613 (ii->ii_type == II_GFUN ? "global" : "static"));
1615 if (die_attr(dw, die, DW_AT_type, 0) != NULL)
1616 ii->ii_dtype = die_lookup_pass1(dw, die, DW_AT_type);
1618 ii->ii_dtype = tdesc_intr_void(dw);
1620 for (arg = die_child(dw, die); arg != NULL;
1621 arg = die_sibling(dw, arg)) {
1624 debug(3, "die %llu: looking at sub member at %llu\n",
1625 off, die_off(dw, die));
1627 if (die_tag(dw, arg) != DW_TAG_formal_parameter)
1630 if ((name1 = die_name(dw, arg)) == NULL) {
1631 terminate("die %llu: func arg %d has no name\n",
1632 off, ii->ii_nargs + 1);
1635 if (strcmp(name1, "...") == 0) {
1644 if (ii->ii_nargs > 0) {
1647 debug(3, "die %llu: function has %d argument%s\n", off,
1648 ii->ii_nargs, (ii->ii_nargs == 1 ? "" : "s"));
1650 ii->ii_args = xcalloc(sizeof (tdesc_t) * ii->ii_nargs);
1652 for (arg = die_child(dw, die), i = 0;
1653 arg != NULL && i < ii->ii_nargs;
1654 arg = die_sibling(dw, arg)) {
1655 if (die_tag(dw, arg) != DW_TAG_formal_parameter)
1658 ii->ii_args[i++] = die_lookup_pass1(dw, arg,
1663 iidesc_add(dw->dw_td->td_iihash, ii);
1668 die_variable_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp __unused)
1673 debug(3, "die %llu: creating object definition\n", off);
1675 if (die_isdecl(dw, die) || (name = die_name(dw, die)) == NULL)
1676 return; /* skip prototypes and nameless objects */
1678 ii = xcalloc(sizeof (iidesc_t));
1679 ii->ii_type = die_isglobal(dw, die) ? II_GVAR : II_SVAR;
1681 ii->ii_dtype = die_lookup_pass1(dw, die, DW_AT_type);
1682 if (ii->ii_type == II_SVAR)
1683 ii->ii_owner = xstrdup(dw->dw_cuname);
1685 iidesc_add(dw->dw_td->td_iihash, ii);
1690 die_fwd_resolve(tdesc_t *fwd, tdesc_t **fwdp, void *private __unused)
1692 if (fwd->t_flags & TDESC_F_RESOLVED)
1695 if (fwd->t_tdesc != NULL) {
1696 debug(3, "tdp %u: unforwarded %s\n", fwd->t_id,
1698 *fwdp = fwd->t_tdesc;
1701 fwd->t_flags |= TDESC_F_RESOLVED;
1708 die_lexblk_descend(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off __unused, tdesc_t *tdp __unused)
1710 Dwarf_Die child = die_child(dw, die);
1713 die_create(dw, child);
1717 * Used to map the die to a routine which can parse it, using the tag to do the
1718 * mapping. While the processing of most tags entails the creation of a tdesc,
1719 * there are a few which don't - primarily those which result in the creation of
1720 * iidescs which refer to existing tdescs.
1723 #define DW_F_NOTDP 0x1 /* Don't create a tdesc for the creator */
1725 typedef struct die_creator {
1728 void (*dc_create)(dwarf_t *, Dwarf_Die, Dwarf_Off, tdesc_t *);
1731 static const die_creator_t die_creators[] = {
1732 { DW_TAG_array_type, 0, die_array_create },
1733 { DW_TAG_enumeration_type, 0, die_enum_create },
1734 { DW_TAG_lexical_block, DW_F_NOTDP, die_lexblk_descend },
1735 { DW_TAG_pointer_type, 0, die_pointer_create },
1736 { DW_TAG_structure_type, 0, die_struct_create },
1737 { DW_TAG_subroutine_type, 0, die_funcptr_create },
1738 { DW_TAG_typedef, 0, die_typedef_create },
1739 { DW_TAG_union_type, 0, die_union_create },
1740 { DW_TAG_base_type, 0, die_base_create },
1741 { DW_TAG_const_type, 0, die_const_create },
1742 { DW_TAG_subprogram, DW_F_NOTDP, die_function_create },
1743 { DW_TAG_variable, DW_F_NOTDP, die_variable_create },
1744 { DW_TAG_volatile_type, 0, die_volatile_create },
1745 { DW_TAG_restrict_type, 0, die_restrict_create },
1749 static const die_creator_t *
1750 die_tag2ctor(Dwarf_Half tag)
1752 const die_creator_t *dc;
1754 for (dc = die_creators; dc->dc_create != NULL; dc++) {
1755 if (dc->dc_tag == tag)
1763 die_create_one(dwarf_t *dw, Dwarf_Die die)
1765 Dwarf_Off off = die_off(dw, die);
1766 const die_creator_t *dc;
1770 debug(3, "die %llu <%llx>: create_one\n", off, off);
1772 if (off > dw->dw_maxoff) {
1773 terminate("illegal die offset %llu (max %llu)\n", off,
1777 tag = die_tag(dw, die);
1779 if ((dc = die_tag2ctor(tag)) == NULL) {
1780 debug(2, "die %llu: ignoring tag type %x\n", off, tag);
1784 if ((tdp = tdesc_lookup(dw, off)) == NULL &&
1785 !(dc->dc_flags & DW_F_NOTDP)) {
1786 tdp = xcalloc(sizeof (tdesc_t));
1792 tdp->t_name = die_name(dw, die);
1794 dc->dc_create(dw, die, off, tdp);
1798 die_create(dwarf_t *dw, Dwarf_Die die)
1801 die_create_one(dw, die);
1802 } while ((die = die_sibling(dw, die)) != NULL);
1805 static tdtrav_cb_f die_resolvers[] = {
1807 NULL, /* intrinsic */
1809 die_array_resolve, /* array */
1810 NULL, /* function */
1811 die_sou_resolve, /* struct */
1812 die_sou_resolve, /* union */
1813 die_enum_resolve, /* enum */
1814 die_fwd_resolve, /* forward */
1816 NULL, /* typedef unres */
1817 NULL, /* volatile */
1819 NULL, /* restrict */
1822 static tdtrav_cb_f die_fail_reporters[] = {
1824 NULL, /* intrinsic */
1826 die_array_failed, /* array */
1827 NULL, /* function */
1828 die_sou_failed, /* struct */
1829 die_sou_failed, /* union */
1833 NULL, /* typedef unres */
1834 NULL, /* volatile */
1836 NULL, /* restrict */
1840 die_resolve(dwarf_t *dw)
1849 (void) iitraverse_hash(dw->dw_td->td_iihash,
1850 &dw->dw_td->td_curvgen, NULL, NULL, die_resolvers, dw);
1852 debug(3, "resolve: pass %d, %u left\n", pass, dw->dw_nunres);
1854 if ((int) dw->dw_nunres == last) {
1855 fprintf(stderr, "%s: failed to resolve the following "
1856 "types:\n", progname);
1858 (void) iitraverse_hash(dw->dw_td->td_iihash,
1859 &dw->dw_td->td_curvgen, NULL, NULL,
1860 die_fail_reporters, dw);
1862 terminate("failed to resolve types\n");
1865 last = dw->dw_nunres;
1867 } while (dw->dw_nunres != 0);
1871 * Any object containing a function or object symbol at any scope should also
1872 * contain DWARF data.
1875 should_have_dwarf(Elf *elf)
1877 Elf_Scn *scn = NULL;
1878 Elf_Data *data = NULL;
1883 boolean_t found = B_FALSE;
1885 while ((scn = elf_nextscn(elf, scn)) != NULL) {
1886 gelf_getshdr(scn, &shdr);
1888 if (shdr.sh_type == SHT_SYMTAB) {
1895 terminate("cannot convert stripped objects\n");
1897 data = elf_getdata(scn, NULL);
1898 nsyms = shdr.sh_size / shdr.sh_entsize;
1900 for (symdx = 0; symdx < nsyms; symdx++) {
1901 gelf_getsym(data, symdx, &sym);
1903 if ((GELF_ST_TYPE(sym.st_info) == STT_FUNC) ||
1904 (GELF_ST_TYPE(sym.st_info) == STT_TLS) ||
1905 (GELF_ST_TYPE(sym.st_info) == STT_OBJECT)) {
1908 name = elf_strptr(elf, shdr.sh_link, sym.st_name);
1910 /* Studio emits these local symbols regardless */
1911 if ((strcmp(name, "Bbss.bss") != 0) &&
1912 (strcmp(name, "Ttbss.bss") != 0) &&
1913 (strcmp(name, "Ddata.data") != 0) &&
1914 (strcmp(name, "Ttdata.data") != 0) &&
1915 (strcmp(name, "Drodata.rodata") != 0))
1925 dw_read(tdata_t *td, Elf *elf, char *filename __unused)
1927 Dwarf_Unsigned abboff, hdrlen, nxthdr;
1928 Dwarf_Half vers, addrsz;
1930 Dwarf_Die child = 0;
1935 bzero(&dw, sizeof (dwarf_t));
1937 dw.dw_ptrsz = elf_ptrsz(elf);
1938 dw.dw_mfgtid_last = TID_MFGTID_BASE;
1939 dw.dw_tidhash = hash_new(TDESC_HASH_BUCKETS, tdesc_idhash, tdesc_idcmp);
1940 dw.dw_fwdhash = hash_new(TDESC_HASH_BUCKETS, tdesc_namehash,
1942 dw.dw_enumhash = hash_new(TDESC_HASH_BUCKETS, tdesc_namehash,
1945 if ((rc = dwarf_elf_init(elf, DW_DLC_READ, &dw.dw_dw,
1946 &dw.dw_err)) == DW_DLV_NO_ENTRY) {
1947 if (should_have_dwarf(elf)) {
1953 } else if (rc != DW_DLV_OK) {
1954 if (dwarf_errno(&dw.dw_err) == DW_DLE_DEBUG_INFO_NULL) {
1956 * There's no type data in the DWARF section, but
1957 * libdwarf is too clever to handle that properly.
1962 terminate("failed to initialize DWARF: %s\n",
1963 dwarf_errmsg(&dw.dw_err));
1966 if ((rc = dwarf_next_cu_header(dw.dw_dw, &hdrlen, &vers, &abboff,
1967 &addrsz, &nxthdr, &dw.dw_err)) != DW_DLV_OK)
1968 terminate("rc = %d %s\n", rc, dwarf_errmsg(&dw.dw_err));
1970 if ((cu = die_sibling(&dw, NULL)) == NULL ||
1971 (((child = die_child(&dw, cu)) == NULL) &&
1972 should_have_dwarf(elf))) {
1973 terminate("file does not contain dwarf type data "
1974 "(try compiling with -g)\n");
1975 } else if (child == NULL) {
1979 dw.dw_maxoff = nxthdr - 1;
1981 if (dw.dw_maxoff > TID_FILEMAX)
1982 terminate("file contains too many types\n");
1984 debug(1, "DWARF version: %d\n", vers);
1985 if (vers != DWARF_VERSION) {
1986 terminate("file contains incompatible version %d DWARF code "
1987 "(version 2 required)\n", vers);
1990 if (die_string(&dw, cu, DW_AT_producer, &prod, 0)) {
1991 debug(1, "DWARF emitter: %s\n", prod);
1995 if ((dw.dw_cuname = die_name(&dw, cu)) != NULL) {
1996 char *base = xstrdup(basename(dw.dw_cuname));
1998 dw.dw_cuname = base;
2000 debug(1, "CU name: %s\n", dw.dw_cuname);
2003 if ((child = die_child(&dw, cu)) != NULL)
2004 die_create(&dw, child);
2006 if ((rc = dwarf_next_cu_header(dw.dw_dw, &hdrlen, &vers, &abboff,
2007 &addrsz, &nxthdr, &dw.dw_err)) != DW_DLV_NO_ENTRY)
2008 terminate("multiple compilation units not supported\n");
2010 (void) dwarf_finish(&dw.dw_dw, &dw.dw_err);
2014 cvt_fixups(td, dw.dw_ptrsz);
2016 /* leak the dwarf_t */