diff options
Diffstat (limited to 'usr/src/tools/ctf/cvt/dwarf.c')
| -rw-r--r-- | usr/src/tools/ctf/cvt/dwarf.c | 2027 |
1 files changed, 0 insertions, 2027 deletions
diff --git a/usr/src/tools/ctf/cvt/dwarf.c b/usr/src/tools/ctf/cvt/dwarf.c deleted file mode 100644 index afca423005..0000000000 --- a/usr/src/tools/ctf/cvt/dwarf.c +++ /dev/null @@ -1,2027 +0,0 @@ -/* - * CDDL HEADER START - * - * The contents of this file are subject to the terms of the - * Common Development and Distribution License (the "License"). - * You may not use this file except in compliance with the License. - * - * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE - * or http://www.opensolaris.org/os/licensing. - * See the License for the specific language governing permissions - * and limitations under the License. - * - * When distributing Covered Code, include this CDDL HEADER in each - * file and include the License file at usr/src/OPENSOLARIS.LICENSE. - * If applicable, add the following below this CDDL HEADER, with the - * fields enclosed by brackets "[]" replaced with your own identifying - * information: Portions Copyright [yyyy] [name of copyright owner] - * - * CDDL HEADER END - */ -/* - * Copyright 2007 Sun Microsystems, Inc. All rights reserved. - * Use is subject to license terms. - */ -/* - * Copyright 2012 Jason King. All rights reserved. - * Use is subject to license terms. - */ - -/* - * DWARF to tdata conversion - * - * For the most part, conversion is straightforward, proceeding in two passes. - * On the first pass, we iterate through every die, creating new type nodes as - * necessary. Referenced tdesc_t's are created in an uninitialized state, thus - * allowing type reference pointers to be filled in. If the tdesc_t - * corresponding to a given die can be completely filled out (sizes and offsets - * calculated, and so forth) without using any referenced types, the tdesc_t is - * marked as resolved. Consider an array type. If the type corresponding to - * the array contents has not yet been processed, we will create a blank tdesc - * for the contents type (only the type ID will be filled in, relying upon the - * later portion of the first pass to encounter and complete the referenced - * type). We will then attempt to determine the size of the array. If the - * array has a byte size attribute, we will have completely characterized the - * array type, and will be able to mark it as resolved. The lack of a byte - * size attribute, on the other hand, will prevent us from fully resolving the - * type, as the size will only be calculable with reference to the contents - * type, which has not, as yet, been encountered. The array type will thus be - * left without the resolved flag, and the first pass will continue. - * - * When we begin the second pass, we will have created tdesc_t nodes for every - * type in the section. We will traverse the tree, from the iidescs down, - * processing each unresolved node. As the referenced nodes will have been - * populated, the array type used in our example above will be able to use the - * size of the referenced types (if available) to determine its own type. The - * traversal will be repeated until all types have been resolved or we have - * failed to make progress. When all tdescs have been resolved, the conversion - * is complete. - * - * There are, as always, a few special cases that are handled during the first - * and second passes: - * - * 1. Empty enums - GCC will occasionally emit an enum without any members. - * Later on in the file, it will emit the same enum type, though this time - * with the full complement of members. All references to the memberless - * enum need to be redirected to the full definition. During the first - * pass, each enum is entered in dm_enumhash, along with a pointer to its - * corresponding tdesc_t. If, during the second pass, we encounter a - * memberless enum, we use the hash to locate the full definition. All - * tdescs referencing the empty enum are then redirected. - * - * 2. Forward declarations - If the compiler sees a forward declaration for - * a structure, followed by the definition of that structure, it will emit - * DWARF data for both the forward declaration and the definition. We need - * to resolve the forward declarations when possible, by redirecting - * forward-referencing tdescs to the actual struct/union definitions. This - * redirection is done completely within the first pass. We begin by - * recording all forward declarations in dw_fwdhash. When we define a - * structure, we check to see if there have been any corresponding forward - * declarations. If so, we redirect the tdescs which referenced the forward - * declarations to the structure or union definition. - * - * XXX see if a post traverser will allow the elimination of repeated pass 2 - * traversals. - */ - -#include <stdio.h> -#include <stdlib.h> -#include <strings.h> -#include <errno.h> -#include <libelf.h> -#include <libdwarf.h> -#include <libgen.h> -#include <dwarf.h> - -#include "ctf_headers.h" -#include "ctftools.h" -#include "memory.h" -#include "list.h" -#include "traverse.h" - -/* The version of DWARF which we support. */ -#define DWARF_VERSION 2 - -/* - * We need to define a couple of our own intrinsics, to smooth out some of the - * differences between the GCC and DevPro DWARF emitters. See the referenced - * routines and the special cases in the file comment for more details. - * - * Type IDs are 32 bits wide. We're going to use the top of that field to - * indicate types that we've created ourselves. - */ -#define TID_FILEMAX 0x3fffffff /* highest tid from file */ -#define TID_VOID 0x40000001 /* see die_void() */ -#define TID_LONG 0x40000002 /* see die_array() */ - -#define TID_MFGTID_BASE 0x40000003 /* first mfg'd tid */ - -/* - * To reduce the staggering amount of error-handling code that would otherwise - * be required, the attribute-retrieval routines handle most of their own - * errors. If the following flag is supplied as the value of the `req' - * argument, they will also handle the absence of a requested attribute by - * terminating the program. - */ -#define DW_ATTR_REQ 1 - -#define TDESC_HASH_BUCKETS 511 - -typedef struct dwarf { - Dwarf_Debug dw_dw; /* for libdwarf */ - Dwarf_Error dw_err; /* for libdwarf */ - Dwarf_Unsigned dw_maxoff; /* highest legal offset in this cu */ - tdata_t *dw_td; /* root of the tdesc/iidesc tree */ - hash_t *dw_tidhash; /* hash of tdescs by t_id */ - hash_t *dw_fwdhash; /* hash of fwd decls by name */ - hash_t *dw_enumhash; /* hash of memberless enums by name */ - tdesc_t *dw_void; /* manufactured void type */ - tdesc_t *dw_long; /* manufactured long type for arrays */ - size_t dw_ptrsz; /* size of a pointer in this file */ - tid_t dw_mfgtid_last; /* last mfg'd type ID used */ - uint_t dw_nunres; /* count of unresolved types */ - char *dw_cuname; /* name of compilation unit */ -} dwarf_t; - -static void die_create_one(dwarf_t *, Dwarf_Die); -static void die_create(dwarf_t *, Dwarf_Die); - -static tid_t -mfgtid_next(dwarf_t *dw) -{ - return (++dw->dw_mfgtid_last); -} - -static void -tdesc_add(dwarf_t *dw, tdesc_t *tdp) -{ - hash_add(dw->dw_tidhash, tdp); -} - -static tdesc_t * -tdesc_lookup(dwarf_t *dw, int tid) -{ - tdesc_t tmpl, *tdp; - - tmpl.t_id = tid; - - if (hash_find(dw->dw_tidhash, &tmpl, (void **)&tdp)) - return (tdp); - else - return (NULL); -} - -/* - * Resolve a tdesc down to a node which should have a size. Returns the size, - * zero if the size hasn't yet been determined. - */ -static size_t -tdesc_size(tdesc_t *tdp) -{ - for (;;) { - switch (tdp->t_type) { - case INTRINSIC: - case POINTER: - case ARRAY: - case FUNCTION: - case STRUCT: - case UNION: - case ENUM: - return (tdp->t_size); - - case FORWARD: - return (0); - - case TYPEDEF: - case VOLATILE: - case CONST: - case RESTRICT: - tdp = tdp->t_tdesc; - continue; - - case 0: /* not yet defined */ - return (0); - - default: - terminate("tdp %u: tdesc_size on unknown type %d\n", - tdp->t_id, tdp->t_type); - } - } -} - -static size_t -tdesc_bitsize(tdesc_t *tdp) -{ - for (;;) { - switch (tdp->t_type) { - case INTRINSIC: - return (tdp->t_intr->intr_nbits); - - case ARRAY: - case FUNCTION: - case STRUCT: - case UNION: - case ENUM: - case POINTER: - return (tdp->t_size * NBBY); - - case FORWARD: - return (0); - - case TYPEDEF: - case VOLATILE: - case RESTRICT: - case CONST: - tdp = tdp->t_tdesc; - continue; - - case 0: /* not yet defined */ - return (0); - - default: - terminate("tdp %u: tdesc_bitsize on unknown type %d\n", - tdp->t_id, tdp->t_type); - } - } -} - -static tdesc_t * -tdesc_basetype(tdesc_t *tdp) -{ - for (;;) { - switch (tdp->t_type) { - case TYPEDEF: - case VOLATILE: - case RESTRICT: - case CONST: - tdp = tdp->t_tdesc; - break; - case 0: /* not yet defined */ - return (NULL); - default: - return (tdp); - } - } -} - -static Dwarf_Off -die_off(dwarf_t *dw, Dwarf_Die die) -{ - Dwarf_Off off; - - if (dwarf_dieoffset(die, &off, &dw->dw_err) == DW_DLV_OK) - return (off); - - terminate("failed to get offset for die: %s\n", - dwarf_errmsg(dw->dw_err)); - /*NOTREACHED*/ - return (0); -} - -static Dwarf_Die -die_sibling(dwarf_t *dw, Dwarf_Die die) -{ - Dwarf_Die sib; - int rc; - - if ((rc = dwarf_siblingof(dw->dw_dw, die, &sib, &dw->dw_err)) == - DW_DLV_OK) - return (sib); - else if (rc == DW_DLV_NO_ENTRY) - return (NULL); - - terminate("die %llu: failed to find type sibling: %s\n", - die_off(dw, die), dwarf_errmsg(dw->dw_err)); - /*NOTREACHED*/ - return (NULL); -} - -static Dwarf_Die -die_child(dwarf_t *dw, Dwarf_Die die) -{ - Dwarf_Die child; - int rc; - - if ((rc = dwarf_child(die, &child, &dw->dw_err)) == DW_DLV_OK) - return (child); - else if (rc == DW_DLV_NO_ENTRY) - return (NULL); - - terminate("die %llu: failed to find type child: %s\n", - die_off(dw, die), dwarf_errmsg(dw->dw_err)); - /*NOTREACHED*/ - return (NULL); -} - -static Dwarf_Half -die_tag(dwarf_t *dw, Dwarf_Die die) -{ - Dwarf_Half tag; - - if (dwarf_tag(die, &tag, &dw->dw_err) == DW_DLV_OK) - return (tag); - - terminate("die %llu: failed to get tag for type: %s\n", - die_off(dw, die), dwarf_errmsg(dw->dw_err)); - /*NOTREACHED*/ - return (0); -} - -static Dwarf_Attribute -die_attr(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, int req) -{ - Dwarf_Attribute attr; - int rc; - - if ((rc = dwarf_attr(die, name, &attr, &dw->dw_err)) == DW_DLV_OK) { - return (attr); - } else if (rc == DW_DLV_NO_ENTRY) { - if (req) { - terminate("die %llu: no attr 0x%x\n", die_off(dw, die), - name); - } else { - return (NULL); - } - } - - terminate("die %llu: failed to get attribute for type: %s\n", - die_off(dw, die), dwarf_errmsg(dw->dw_err)); - /*NOTREACHED*/ - return (NULL); -} - -static Dwarf_Half -die_attr_form(dwarf_t *dw, Dwarf_Attribute attr) -{ - Dwarf_Half form; - - if (dwarf_whatform(attr, &form, &dw->dw_err) == DW_DLV_OK) - return (form); - - terminate("failed to get attribute form for type: %s\n", - dwarf_errmsg(dw->dw_err)); - /*NOTREACHED*/ - return (0); -} - -/* - * the following functions lookup the value of an attribute in a DIE: - * - * die_signed - * die_unsigned - * die_bool - * die_string - * - * They all take the same parameters (with the exception of valp which is - * a pointer to the type of the attribute we are looking up): - * - * dw - the dwarf object to look in - * die - the DIE we're interested in - * name - the name of the attribute to lookup - * valp - pointer to where the value of the attribute is placed - * req - if the value is required (0 / non-zero) - * - * If the attribute is not found, one of the following happens: - * - program terminates (req is non-zero) - * - function returns 0 - * - * If the value is found, and in a form (class) we can handle, the function - * returns 1. - * - * Currently, we can only handle attribute values that are stored as - * constants (immediate value). If an attribute has a form we cannot - * handle (for example VLAs may store the dimensions of the array - * as a DWARF expression that can compute it at runtime by reading - * values off the stack or other locations in memory), it is treated - * the same as if the attribute does not exist. - */ -static int -die_signed(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, Dwarf_Signed *valp, - int req) -{ - Dwarf_Attribute attr; - Dwarf_Signed val; - - if ((attr = die_attr(dw, die, name, req)) == NULL) - return (0); /* die_attr will terminate for us if necessary */ - - if (dwarf_formsdata(attr, &val, &dw->dw_err) != DW_DLV_OK) { - if (req == 0) - return (0); - - terminate("die %llu: failed to get signed (form 0x%x)\n", - die_off(dw, die), die_attr_form(dw, attr)); - } - - dwarf_dealloc(dw->dw_dw, attr, DW_DLA_ATTR); - - *valp = val; - return (1); -} - -static int -die_unsigned(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, Dwarf_Unsigned *valp, - int req) -{ - Dwarf_Attribute attr; - Dwarf_Unsigned val; - - if ((attr = die_attr(dw, die, name, req)) == NULL) - return (0); /* die_attr will terminate for us if necessary */ - - if (dwarf_formudata(attr, &val, &dw->dw_err) != DW_DLV_OK) { - if (req == 0) - return (0); - - terminate("die %llu: failed to get unsigned (form 0x%x)\n", - die_off(dw, die), die_attr_form(dw, attr)); - } - - dwarf_dealloc(dw->dw_dw, attr, DW_DLA_ATTR); - - *valp = val; - return (1); -} - -static int -die_bool(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, Dwarf_Bool *valp, int req) -{ - Dwarf_Attribute attr; - Dwarf_Bool val; - - if ((attr = die_attr(dw, die, name, req)) == NULL) - return (0); /* die_attr will terminate for us if necessary */ - - if (dwarf_formflag(attr, &val, &dw->dw_err) != DW_DLV_OK) { - if (req == 0) - return (0); - - terminate("die %llu: failed to get bool (form 0x%x)\n", - die_off(dw, die), die_attr_form(dw, attr)); - } - - dwarf_dealloc(dw->dw_dw, attr, DW_DLA_ATTR); - - *valp = val; - return (1); -} - -static int -die_string(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, char **strp, int req) -{ - Dwarf_Attribute attr; - char *str; - - if ((attr = die_attr(dw, die, name, req)) == NULL) - return (0); /* die_attr will terminate for us if necessary */ - - if (dwarf_formstring(attr, &str, &dw->dw_err) != DW_DLV_OK) { - if (req == 0) - return (0); - - terminate("die %llu: failed to get string (form 0x%x)\n", - die_off(dw, die), die_attr_form(dw, attr)); - } - - *strp = xstrdup(str); - dwarf_dealloc(dw->dw_dw, str, DW_DLA_STRING); - - return (1); -} - -static Dwarf_Off -die_attr_ref(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name) -{ - Dwarf_Attribute attr; - Dwarf_Off off; - - attr = die_attr(dw, die, name, DW_ATTR_REQ); - - if (dwarf_formref(attr, &off, &dw->dw_err) != DW_DLV_OK) { - terminate("die %llu: failed to get ref (form 0x%x)\n", - die_off(dw, die), die_attr_form(dw, attr)); - } - - dwarf_dealloc(dw->dw_dw, attr, DW_DLA_ATTR); - - return (off); -} - -static char * -die_name(dwarf_t *dw, Dwarf_Die die) -{ - char *str = NULL; - - (void) die_string(dw, die, DW_AT_name, &str, 0); - - return (str); -} - -static int -die_isdecl(dwarf_t *dw, Dwarf_Die die) -{ - Dwarf_Bool val; - - return (die_bool(dw, die, DW_AT_declaration, &val, 0) && val); -} - -static int -die_isglobal(dwarf_t *dw, Dwarf_Die die) -{ - Dwarf_Signed vis; - Dwarf_Bool ext; - - /* - * Some compilers (gcc) use DW_AT_external to indicate function - * visibility. Others (Sun) use DW_AT_visibility. - */ - if (die_signed(dw, die, DW_AT_visibility, &vis, 0)) - return (vis == DW_VIS_exported); - else - return (die_bool(dw, die, DW_AT_external, &ext, 0) && ext); -} - -static tdesc_t * -die_add(dwarf_t *dw, Dwarf_Off off) -{ - tdesc_t *tdp = xcalloc(sizeof (tdesc_t)); - - tdp->t_id = off; - - tdesc_add(dw, tdp); - - return (tdp); -} - -static tdesc_t * -die_lookup_pass1(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name) -{ - Dwarf_Off ref = die_attr_ref(dw, die, name); - tdesc_t *tdp; - - if ((tdp = tdesc_lookup(dw, ref)) != NULL) - return (tdp); - - return (die_add(dw, ref)); -} - -static int -die_mem_offset(dwarf_t *dw, Dwarf_Die die, Dwarf_Half name, - Dwarf_Unsigned *valp, int req) -{ - Dwarf_Attribute attr; - Dwarf_Locdesc *loc; - Dwarf_Signed locnum; - - if ((attr = die_attr(dw, die, name, req)) == NULL) - return (0); /* die_attr will terminate for us if necessary */ - - if (dwarf_loclist(attr, &loc, &locnum, &dw->dw_err) != DW_DLV_OK) { - terminate("die %llu: failed to get mem offset location list\n", - die_off(dw, die)); - } - - dwarf_dealloc(dw->dw_dw, attr, DW_DLA_ATTR); - - if (locnum != 1 || loc->ld_s->lr_atom != DW_OP_plus_uconst) { - terminate("die %llu: cannot parse member offset\n", - die_off(dw, die)); - } - - *valp = loc->ld_s->lr_number; - - dwarf_dealloc(dw->dw_dw, loc->ld_s, DW_DLA_LOC_BLOCK); - dwarf_dealloc(dw->dw_dw, loc, DW_DLA_LOCDESC); - - return (1); -} - -static tdesc_t * -tdesc_intr_common(dwarf_t *dw, int tid, const char *name, size_t sz) -{ - tdesc_t *tdp; - intr_t *intr; - - intr = xcalloc(sizeof (intr_t)); - intr->intr_type = INTR_INT; - intr->intr_signed = 1; - intr->intr_nbits = sz * NBBY; - - tdp = xcalloc(sizeof (tdesc_t)); - tdp->t_name = xstrdup(name); - tdp->t_size = sz; - tdp->t_id = tid; - tdp->t_type = INTRINSIC; - tdp->t_intr = intr; - tdp->t_flags = TDESC_F_RESOLVED; - - tdesc_add(dw, tdp); - - return (tdp); -} - -/* - * Manufacture a void type. Used for gcc-emitted stabs, where the lack of a - * type reference implies a reference to a void type. A void *, for example - * will be represented by a pointer die without a DW_AT_type. CTF requires - * that pointer nodes point to something, so we'll create a void for use as - * the target. Note that the DWARF data may already create a void type. Ours - * would then be a duplicate, but it'll be removed in the self-uniquification - * merge performed at the completion of DWARF->tdesc conversion. - */ -static tdesc_t * -tdesc_intr_void(dwarf_t *dw) -{ - if (dw->dw_void == NULL) - dw->dw_void = tdesc_intr_common(dw, TID_VOID, "void", 0); - - return (dw->dw_void); -} - -static tdesc_t * -tdesc_intr_long(dwarf_t *dw) -{ - if (dw->dw_long == NULL) { - dw->dw_long = tdesc_intr_common(dw, TID_LONG, "long", - dw->dw_ptrsz); - } - - return (dw->dw_long); -} - -/* - * Used for creating bitfield types. We create a copy of an existing intrinsic, - * adjusting the size of the copy to match what the caller requested. The - * caller can then use the copy as the type for a bitfield structure member. - */ -static tdesc_t * -tdesc_intr_clone(dwarf_t *dw, tdesc_t *old, size_t bitsz) -{ - tdesc_t *new = xcalloc(sizeof (tdesc_t)); - - if (!(old->t_flags & TDESC_F_RESOLVED)) { - terminate("tdp %u: attempt to make a bit field from an " - "unresolved type\n", old->t_id); - } - - new->t_name = xstrdup(old->t_name); - new->t_size = old->t_size; - new->t_id = mfgtid_next(dw); - new->t_type = INTRINSIC; - new->t_flags = TDESC_F_RESOLVED; - - new->t_intr = xcalloc(sizeof (intr_t)); - bcopy(old->t_intr, new->t_intr, sizeof (intr_t)); - new->t_intr->intr_nbits = bitsz; - - tdesc_add(dw, new); - - return (new); -} - -static void -tdesc_array_create(dwarf_t *dw, Dwarf_Die dim, tdesc_t *arrtdp, - tdesc_t *dimtdp) -{ - Dwarf_Unsigned uval; - Dwarf_Signed sval; - tdesc_t *ctdp; - Dwarf_Die dim2; - ardef_t *ar; - - if ((dim2 = die_sibling(dw, dim)) == NULL) { - ctdp = arrtdp; - } else if (die_tag(dw, dim2) == DW_TAG_subrange_type) { - ctdp = xcalloc(sizeof (tdesc_t)); - ctdp->t_id = mfgtid_next(dw); - debug(3, "die %llu: creating new type %u for sub-dimension\n", - die_off(dw, dim2), ctdp->t_id); - tdesc_array_create(dw, dim2, arrtdp, ctdp); - } else { - terminate("die %llu: unexpected non-subrange node in array\n", - die_off(dw, dim2)); - } - - dimtdp->t_type = ARRAY; - dimtdp->t_ardef = ar = xcalloc(sizeof (ardef_t)); - - /* - * Array bounds can be signed or unsigned, but there are several kinds - * of signless forms (data1, data2, etc) that take their sign from the - * routine that is trying to interpret them. That is, data1 can be - * either signed or unsigned, depending on whether you use the signed or - * unsigned accessor function. GCC will use the signless forms to store - * unsigned values which have their high bit set, so we need to try to - * read them first as unsigned to get positive values. We could also - * try signed first, falling back to unsigned if we got a negative - * value. - */ - if (die_unsigned(dw, dim, DW_AT_upper_bound, &uval, 0)) - ar->ad_nelems = uval + 1; - else if (die_signed(dw, dim, DW_AT_upper_bound, &sval, 0)) - ar->ad_nelems = sval + 1; - else - ar->ad_nelems = 0; - - /* - * Different compilers use different index types. Force the type to be - * a common, known value (long). - */ - ar->ad_idxtype = tdesc_intr_long(dw); - ar->ad_contents = ctdp; - - if (ar->ad_contents->t_size != 0) { - dimtdp->t_size = ar->ad_contents->t_size * ar->ad_nelems; - dimtdp->t_flags |= TDESC_F_RESOLVED; - } -} - -/* - * Create a tdesc from an array node. Some arrays will come with byte size - * attributes, and thus can be resolved immediately. Others don't, and will - * need to wait until the second pass for resolution. - */ -static void -die_array_create(dwarf_t *dw, Dwarf_Die arr, Dwarf_Off off, tdesc_t *tdp) -{ - tdesc_t *arrtdp = die_lookup_pass1(dw, arr, DW_AT_type); - Dwarf_Unsigned uval; - Dwarf_Die dim; - - debug(3, "die %llu: creating array\n", off); - - if ((dim = die_child(dw, arr)) == NULL || - die_tag(dw, dim) != DW_TAG_subrange_type) - terminate("die %llu: failed to retrieve array bounds\n", off); - - tdesc_array_create(dw, dim, arrtdp, tdp); - - if (die_unsigned(dw, arr, DW_AT_byte_size, &uval, 0)) { - tdesc_t *dimtdp; - int flags; - - tdp->t_size = uval; - - /* - * Ensure that sub-dimensions have sizes too before marking - * as resolved. - */ - flags = TDESC_F_RESOLVED; - for (dimtdp = tdp->t_ardef->ad_contents; - dimtdp->t_type == ARRAY; - dimtdp = dimtdp->t_ardef->ad_contents) { - if (!(dimtdp->t_flags & TDESC_F_RESOLVED)) { - flags = 0; - break; - } - } - - tdp->t_flags |= flags; - } - - debug(3, "die %llu: array nelems %u size %u\n", off, - tdp->t_ardef->ad_nelems, tdp->t_size); -} - -/*ARGSUSED1*/ -static int -die_array_resolve(tdesc_t *tdp, tdesc_t **tdpp, void *private) -{ - dwarf_t *dw = private; - size_t sz; - - if (tdp->t_flags & TDESC_F_RESOLVED) - return (1); - - debug(3, "trying to resolve array %d (cont %d)\n", tdp->t_id, - tdp->t_ardef->ad_contents->t_id); - - if ((sz = tdesc_size(tdp->t_ardef->ad_contents)) == 0) { - debug(3, "unable to resolve array %s (%d) contents %d\n", - tdesc_name(tdp), tdp->t_id, - tdp->t_ardef->ad_contents->t_id); - - dw->dw_nunres++; - return (1); - } - - tdp->t_size = sz * tdp->t_ardef->ad_nelems; - tdp->t_flags |= TDESC_F_RESOLVED; - - debug(3, "resolved array %d: %u bytes\n", tdp->t_id, tdp->t_size); - - return (1); -} - -/*ARGSUSED1*/ -static int -die_array_failed(tdesc_t *tdp, tdesc_t **tdpp, void *private) -{ - tdesc_t *cont = tdp->t_ardef->ad_contents; - - if (tdp->t_flags & TDESC_F_RESOLVED) - return (1); - - fprintf(stderr, "Array %d: failed to size contents type %s (%d)\n", - tdp->t_id, tdesc_name(cont), cont->t_id); - - return (1); -} - -/* - * Most enums (those with members) will be resolved during this first pass. - * Others - those without members (see the file comment) - won't be, and will - * need to wait until the second pass when they can be matched with their full - * definitions. - */ -static void -die_enum_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) -{ - Dwarf_Die mem; - Dwarf_Unsigned uval; - Dwarf_Signed sval; - - debug(3, "die %llu: creating enum\n", off); - - tdp->t_type = ENUM; - - (void) die_unsigned(dw, die, DW_AT_byte_size, &uval, DW_ATTR_REQ); - tdp->t_size = uval; - - if ((mem = die_child(dw, die)) != NULL) { - elist_t **elastp = &tdp->t_emem; - - do { - elist_t *el; - - if (die_tag(dw, mem) != DW_TAG_enumerator) { - /* Nested type declaration */ - die_create_one(dw, mem); - continue; - } - - el = xcalloc(sizeof (elist_t)); - el->el_name = die_name(dw, mem); - - /* - * We have to be careful here: newer GCCs generate DWARF - * where an unsigned value will happily pass - * die_signed(). Since negative values will fail - * die_unsigned(), we try that first to make sure we get - * the right value. - */ - if (die_unsigned(dw, mem, DW_AT_const_value, - &uval, 0)) { - el->el_number = uval; - } else if (die_signed(dw, mem, DW_AT_const_value, - &sval, 0)) { - el->el_number = sval; - } else { - terminate("die %llu: enum %llu: member without " - "value\n", off, die_off(dw, mem)); - } - - debug(3, "die %llu: enum %llu: created %s = %d\n", off, - die_off(dw, mem), el->el_name, el->el_number); - - *elastp = el; - elastp = &el->el_next; - - } while ((mem = die_sibling(dw, mem)) != NULL); - - hash_add(dw->dw_enumhash, tdp); - - tdp->t_flags |= TDESC_F_RESOLVED; - - if (tdp->t_name != NULL) { - iidesc_t *ii = xcalloc(sizeof (iidesc_t)); - ii->ii_type = II_SOU; - ii->ii_name = xstrdup(tdp->t_name); - ii->ii_dtype = tdp; - - iidesc_add(dw->dw_td->td_iihash, ii); - } - } -} - -static int -die_enum_match(void *arg1, void *arg2) -{ - tdesc_t *tdp = arg1, **fullp = arg2; - - if (tdp->t_emem != NULL) { - *fullp = tdp; - return (-1); /* stop the iteration */ - } - - return (0); -} - -/*ARGSUSED1*/ -static int -die_enum_resolve(tdesc_t *tdp, tdesc_t **tdpp, void *private) -{ - dwarf_t *dw = private; - tdesc_t *full = NULL; - - if (tdp->t_flags & TDESC_F_RESOLVED) - return (1); - - (void) hash_find_iter(dw->dw_enumhash, tdp, die_enum_match, &full); - - /* - * The answer to this one won't change from iteration to iteration, - * so don't even try. - */ - if (full == NULL) { - terminate("tdp %u: enum %s has no members\n", tdp->t_id, - tdesc_name(tdp)); - } - - debug(3, "tdp %u: enum %s redirected to %u\n", tdp->t_id, - tdesc_name(tdp), full->t_id); - - tdp->t_flags |= TDESC_F_RESOLVED; - - return (1); -} - -static int -die_fwd_map(void *arg1, void *arg2) -{ - tdesc_t *fwd = arg1, *sou = arg2; - - debug(3, "tdp %u: mapped forward %s to sou %u\n", fwd->t_id, - tdesc_name(fwd), sou->t_id); - fwd->t_tdesc = sou; - - return (0); -} - -/* - * Structures and unions will never be resolved during the first pass, as we - * won't be able to fully determine the member sizes. The second pass, which - * have access to sizing information, will be able to complete the resolution. - */ -static void -die_sou_create(dwarf_t *dw, Dwarf_Die str, Dwarf_Off off, tdesc_t *tdp, - int type, const char *typename) -{ - Dwarf_Unsigned sz, bitsz, bitoff; - Dwarf_Die mem; - mlist_t *ml, **mlastp; - iidesc_t *ii; - - tdp->t_type = (die_isdecl(dw, str) ? FORWARD : type); - - debug(3, "die %llu: creating %s %s\n", off, - (tdp->t_type == FORWARD ? "forward decl" : typename), - tdesc_name(tdp)); - - if (tdp->t_type == FORWARD) { - hash_add(dw->dw_fwdhash, tdp); - return; - } - - (void) hash_find_iter(dw->dw_fwdhash, tdp, die_fwd_map, tdp); - - (void) die_unsigned(dw, str, DW_AT_byte_size, &sz, DW_ATTR_REQ); - tdp->t_size = sz; - - /* - * GCC allows empty SOUs as an extension. - */ - if ((mem = die_child(dw, str)) == NULL) - goto out; - - mlastp = &tdp->t_members; - - do { - Dwarf_Off memoff = die_off(dw, mem); - Dwarf_Half tag = die_tag(dw, mem); - Dwarf_Unsigned mloff; - - if (tag != DW_TAG_member) { - /* Nested type declaration */ - die_create_one(dw, mem); - continue; - } - - debug(3, "die %llu: mem %llu: creating member\n", off, memoff); - - ml = xcalloc(sizeof (mlist_t)); - - /* - * This could be a GCC anon struct/union member, so we'll allow - * an empty name, even though nothing can really handle them - * properly. Note that some versions of GCC miss out debug - * info for anon structs, though recent versions are fixed (gcc - * bug 11816). - */ - if ((ml->ml_name = die_name(dw, mem)) == NULL) - ml->ml_name = ""; - - ml->ml_type = die_lookup_pass1(dw, mem, DW_AT_type); - - if (die_mem_offset(dw, mem, DW_AT_data_member_location, - &mloff, 0)) { - debug(3, "die %llu: got mloff %llx\n", off, - (u_longlong_t)mloff); - ml->ml_offset = mloff * 8; - } - - if (die_unsigned(dw, mem, DW_AT_bit_size, &bitsz, 0)) - ml->ml_size = bitsz; - else - ml->ml_size = tdesc_bitsize(ml->ml_type); - - if (die_unsigned(dw, mem, DW_AT_bit_offset, &bitoff, 0)) { -#ifdef _BIG_ENDIAN - ml->ml_offset += bitoff; -#else - ml->ml_offset += tdesc_bitsize(ml->ml_type) - bitoff - - ml->ml_size; -#endif - } - - debug(3, "die %llu: mem %llu: created \"%s\" (off %u sz %u)\n", - off, memoff, ml->ml_name, ml->ml_offset, ml->ml_size); - - *mlastp = ml; - mlastp = &ml->ml_next; - } while ((mem = die_sibling(dw, mem)) != NULL); - - /* - * GCC will attempt to eliminate unused types, thus decreasing the - * size of the emitted dwarf. That is, if you declare a foo_t in your - * header, include said header in your source file, and neglect to - * actually use (directly or indirectly) the foo_t in the source file, - * the foo_t won't make it into the emitted DWARF. So, at least, goes - * the theory. - * - * Occasionally, it'll emit the DW_TAG_structure_type for the foo_t, - * and then neglect to emit the members. Strangely, the loner struct - * tag will always be followed by a proper nested declaration of - * something else. This is clearly a bug, but we're not going to have - * time to get it fixed before this goo goes back, so we'll have to work - * around it. If we see a no-membered struct with a nested declaration - * (i.e. die_child of the struct tag won't be null), we'll ignore it. - * Being paranoid, we won't simply remove it from the hash. Instead, - * we'll decline to create an iidesc for it, thus ensuring that this - * type won't make it into the output file. To be safe, we'll also - * change the name. - */ - if (tdp->t_members == NULL) { - const char *old = tdesc_name(tdp); - size_t newsz = 7 + strlen(old) + 1; - char *new = xmalloc(newsz); - (void) snprintf(new, newsz, "orphan %s", old); - - debug(3, "die %llu: worked around %s %s\n", off, typename, old); - - if (tdp->t_name != NULL) - free(tdp->t_name); - tdp->t_name = new; - return; - } - -out: - if (tdp->t_name != NULL) { - ii = xcalloc(sizeof (iidesc_t)); - ii->ii_type = II_SOU; - ii->ii_name = xstrdup(tdp->t_name); - ii->ii_dtype = tdp; - - iidesc_add(dw->dw_td->td_iihash, ii); - } -} - -static void -die_struct_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) -{ - die_sou_create(dw, die, off, tdp, STRUCT, "struct"); -} - -static void -die_union_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) -{ - die_sou_create(dw, die, off, tdp, UNION, "union"); -} - -/*ARGSUSED1*/ -static int -die_sou_resolve(tdesc_t *tdp, tdesc_t **tdpp, void *private) -{ - dwarf_t *dw = private; - mlist_t *ml; - tdesc_t *mt; - - if (tdp->t_flags & TDESC_F_RESOLVED) - return (1); - - debug(3, "resolving sou %s\n", tdesc_name(tdp)); - - for (ml = tdp->t_members; ml != NULL; ml = ml->ml_next) { - if (ml->ml_size == 0) { - mt = tdesc_basetype(ml->ml_type); - - if ((ml->ml_size = tdesc_bitsize(mt)) != 0) - continue; - - /* - * For empty members, or GCC/C99 flexible array - * members, a size of 0 is correct. - */ - if (mt->t_members == NULL) - continue; - if (mt->t_type == ARRAY && mt->t_ardef->ad_nelems == 0) - continue; - - dw->dw_nunres++; - return (1); - } - - if ((mt = tdesc_basetype(ml->ml_type)) == NULL) { - dw->dw_nunres++; - return (1); - } - - if (ml->ml_size != 0 && mt->t_type == INTRINSIC && - mt->t_intr->intr_nbits != ml->ml_size) { - /* - * This member is a bitfield, and needs to reference - * an intrinsic type with the same width. If the - * currently-referenced type isn't of the same width, - * we'll copy it, adjusting the width of the copy to - * the size we'd like. - */ - debug(3, "tdp %u: creating bitfield for %d bits\n", - tdp->t_id, ml->ml_size); - - ml->ml_type = tdesc_intr_clone(dw, mt, ml->ml_size); - } - } - - tdp->t_flags |= TDESC_F_RESOLVED; - - return (1); -} - -/*ARGSUSED1*/ -static int -die_sou_failed(tdesc_t *tdp, tdesc_t **tdpp, void *private) -{ - const char *typename = (tdp->t_type == STRUCT ? "struct" : "union"); - mlist_t *ml; - - if (tdp->t_flags & TDESC_F_RESOLVED) - return (1); - - for (ml = tdp->t_members; ml != NULL; ml = ml->ml_next) { - if (ml->ml_size == 0) { - fprintf(stderr, "%s %d: failed to size member \"%s\" " - "of type %s (%d)\n", typename, tdp->t_id, - ml->ml_name, tdesc_name(ml->ml_type), - ml->ml_type->t_id); - } - } - - return (1); -} - -static void -die_funcptr_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) -{ - Dwarf_Attribute attr; - Dwarf_Half tag; - Dwarf_Die arg; - fndef_t *fn; - int i; - - debug(3, "die %llu: creating function pointer\n", off); - - /* - * We'll begin by processing any type definition nodes that may be - * lurking underneath this one. - */ - for (arg = die_child(dw, die); arg != NULL; - arg = die_sibling(dw, arg)) { - if ((tag = die_tag(dw, arg)) != DW_TAG_formal_parameter && - tag != DW_TAG_unspecified_parameters) { - /* Nested type declaration */ - die_create_one(dw, arg); - } - } - - if (die_isdecl(dw, die)) { - /* - * This is a prototype. We don't add prototypes to the - * tree, so we're going to drop the tdesc. Unfortunately, - * it has already been added to the tree. Nobody will reference - * it, though, and it will be leaked. - */ - return; - } - - fn = xcalloc(sizeof (fndef_t)); - - tdp->t_type = FUNCTION; - - if ((attr = die_attr(dw, die, DW_AT_type, 0)) != NULL) { - dwarf_dealloc(dw->dw_dw, attr, DW_DLA_ATTR); - fn->fn_ret = die_lookup_pass1(dw, die, DW_AT_type); - } else { - fn->fn_ret = tdesc_intr_void(dw); - } - - /* - * Count the arguments to the function, then read them in. - */ - for (fn->fn_nargs = 0, arg = die_child(dw, die); arg != NULL; - arg = die_sibling(dw, arg)) { - if ((tag = die_tag(dw, arg)) == DW_TAG_formal_parameter) - fn->fn_nargs++; - else if (tag == DW_TAG_unspecified_parameters && - fn->fn_nargs > 0) - fn->fn_vargs = 1; - } - - if (fn->fn_nargs != 0) { - debug(3, "die %llu: adding %d argument%s\n", off, fn->fn_nargs, - (fn->fn_nargs > 1 ? "s" : "")); - - fn->fn_args = xcalloc(sizeof (tdesc_t *) * fn->fn_nargs); - for (i = 0, arg = die_child(dw, die); - arg != NULL && i < fn->fn_nargs; - arg = die_sibling(dw, arg)) { - if (die_tag(dw, arg) != DW_TAG_formal_parameter) - continue; - - fn->fn_args[i++] = die_lookup_pass1(dw, arg, - DW_AT_type); - } - } - - tdp->t_fndef = fn; - tdp->t_flags |= TDESC_F_RESOLVED; -} - -/* - * GCC and DevPro use different names for the base types. While the terms are - * the same, they are arranged in a different order. Some terms, such as int, - * are implied in one, and explicitly named in the other. Given a base type - * as input, this routine will return a common name, along with an intr_t - * that reflects said name. - */ -static intr_t * -die_base_name_parse(const char *name, char **newp) -{ - char buf[100]; - char *base, *c; - int nlong = 0, nshort = 0, nchar = 0, nint = 0; - int sign = 1; - char fmt = '\0'; - intr_t *intr; - - if (strlen(name) > sizeof (buf) - 1) - terminate("base type name \"%s\" is too long\n", name); - - strncpy(buf, name, sizeof (buf)); - - for (c = strtok(buf, " "); c != NULL; c = strtok(NULL, " ")) { - if (strcmp(c, "signed") == 0) - sign = 1; - else if (strcmp(c, "unsigned") == 0) - sign = 0; - else if (strcmp(c, "long") == 0) - nlong++; - else if (strcmp(c, "char") == 0) { - nchar++; - fmt = 'c'; - } else if (strcmp(c, "short") == 0) - nshort++; - else if (strcmp(c, "int") == 0) - nint++; - else { - /* - * If we don't recognize any of the tokens, we'll tell - * the caller to fall back to the dwarf-provided - * encoding information. - */ - return (NULL); - } - } - - if (nchar > 1 || nshort > 1 || nint > 1 || nlong > 2) - return (NULL); - - if (nchar > 0) { - if (nlong > 0 || nshort > 0 || nint > 0) - return (NULL); - - base = "char"; - - } else if (nshort > 0) { - if (nlong > 0) - return (NULL); - - base = "short"; - - } else if (nlong > 0) { - base = "long"; - - } else { - base = "int"; - } - - intr = xcalloc(sizeof (intr_t)); - intr->intr_type = INTR_INT; - intr->intr_signed = sign; - intr->intr_iformat = fmt; - - snprintf(buf, sizeof (buf), "%s%s%s", - (sign ? "" : "unsigned "), - (nlong > 1 ? "long " : ""), - base); - - *newp = xstrdup(buf); - return (intr); -} - -typedef struct fp_size_map { - size_t fsm_typesz[2]; /* size of {32,64} type */ - uint_t fsm_enc[3]; /* CTF_FP_* for {bare,cplx,imagry} type */ -} fp_size_map_t; - -static const fp_size_map_t fp_encodings[] = { - { { 4, 4 }, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } }, - { { 8, 8 }, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } }, -#ifdef __sparc - { { 16, 16 }, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } }, -#else - { { 12, 16 }, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } }, -#endif - { { 0, 0 } } -}; - -static uint_t -die_base_type2enc(dwarf_t *dw, Dwarf_Off off, Dwarf_Signed enc, size_t sz) -{ - const fp_size_map_t *map = fp_encodings; - uint_t szidx = dw->dw_ptrsz == sizeof (uint64_t); - uint_t mult = 1, col = 0; - - if (enc == DW_ATE_complex_float) { - mult = 2; - col = 1; - } else if (enc == DW_ATE_imaginary_float || - enc == DW_ATE_SUN_imaginary_float) - col = 2; - - while (map->fsm_typesz[szidx] != 0) { - if (map->fsm_typesz[szidx] * mult == sz) - return (map->fsm_enc[col]); - map++; - } - - terminate("die %llu: unrecognized real type size %u\n", off, sz); - /*NOTREACHED*/ - return (0); -} - -static intr_t * -die_base_from_dwarf(dwarf_t *dw, Dwarf_Die base, Dwarf_Off off, size_t sz) -{ - intr_t *intr = xcalloc(sizeof (intr_t)); - Dwarf_Signed enc; - - (void) die_signed(dw, base, DW_AT_encoding, &enc, DW_ATTR_REQ); - - switch (enc) { - case DW_ATE_unsigned: - case DW_ATE_address: - intr->intr_type = INTR_INT; - break; - case DW_ATE_unsigned_char: - intr->intr_type = INTR_INT; - intr->intr_iformat = 'c'; - break; - case DW_ATE_signed: - intr->intr_type = INTR_INT; - intr->intr_signed = 1; - break; - case DW_ATE_signed_char: - intr->intr_type = INTR_INT; - intr->intr_signed = 1; - intr->intr_iformat = 'c'; - break; - case DW_ATE_boolean: - intr->intr_type = INTR_INT; - intr->intr_signed = 1; - intr->intr_iformat = 'b'; - break; - case DW_ATE_float: - case DW_ATE_complex_float: - case DW_ATE_imaginary_float: - case DW_ATE_SUN_imaginary_float: - case DW_ATE_SUN_interval_float: - intr->intr_type = INTR_REAL; - intr->intr_signed = 1; - intr->intr_fformat = die_base_type2enc(dw, off, enc, sz); - break; - default: - terminate("die %llu: unknown base type encoding 0x%llx\n", - off, enc); - } - - return (intr); -} - -static void -die_base_create(dwarf_t *dw, Dwarf_Die base, Dwarf_Off off, tdesc_t *tdp) -{ - Dwarf_Unsigned sz; - intr_t *intr; - char *new; - - debug(3, "die %llu: creating base type\n", off); - - /* - * The compilers have their own clever (internally inconsistent) ideas - * as to what base types should look like. Some times gcc will, for - * example, use DW_ATE_signed_char for char. Other times, however, it - * will use DW_ATE_signed. Needless to say, this causes some problems - * down the road, particularly with merging. We do, however, use the - * DWARF idea of type sizes, as this allows us to avoid caring about - * the data model. - */ - (void) die_unsigned(dw, base, DW_AT_byte_size, &sz, DW_ATTR_REQ); - - if (tdp->t_name == NULL) - terminate("die %llu: base type without name\n", off); - - /* XXX make a name parser for float too */ - if ((intr = die_base_name_parse(tdp->t_name, &new)) != NULL) { - /* Found it. We'll use the parsed version */ - debug(3, "die %llu: name \"%s\" remapped to \"%s\"\n", off, - tdesc_name(tdp), new); - - free(tdp->t_name); - tdp->t_name = new; - } else { - /* - * We didn't recognize the type, so we'll create an intr_t - * based on the DWARF data. - */ - debug(3, "die %llu: using dwarf data for base \"%s\"\n", off, - tdesc_name(tdp)); - - intr = die_base_from_dwarf(dw, base, off, sz); - } - - intr->intr_nbits = sz * 8; - - tdp->t_type = INTRINSIC; - tdp->t_intr = intr; - tdp->t_size = sz; - - tdp->t_flags |= TDESC_F_RESOLVED; -} - -static void -die_through_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp, - int type, const char *typename) -{ - Dwarf_Attribute attr; - - debug(3, "die %llu: creating %s\n", off, typename); - - tdp->t_type = type; - - if ((attr = die_attr(dw, die, DW_AT_type, 0)) != NULL) { - dwarf_dealloc(dw->dw_dw, attr, DW_DLA_ATTR); - tdp->t_tdesc = die_lookup_pass1(dw, die, DW_AT_type); - } else { - tdp->t_tdesc = tdesc_intr_void(dw); - } - - if (type == POINTER) - tdp->t_size = dw->dw_ptrsz; - - tdp->t_flags |= TDESC_F_RESOLVED; - - if (type == TYPEDEF) { - iidesc_t *ii = xcalloc(sizeof (iidesc_t)); - ii->ii_type = II_TYPE; - ii->ii_name = xstrdup(tdp->t_name); - ii->ii_dtype = tdp; - - iidesc_add(dw->dw_td->td_iihash, ii); - } -} - -static void -die_typedef_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) -{ - die_through_create(dw, die, off, tdp, TYPEDEF, "typedef"); -} - -static void -die_const_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) -{ - die_through_create(dw, die, off, tdp, CONST, "const"); -} - -static void -die_pointer_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) -{ - die_through_create(dw, die, off, tdp, POINTER, "pointer"); -} - -static void -die_restrict_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) -{ - die_through_create(dw, die, off, tdp, RESTRICT, "restrict"); -} - -static void -die_volatile_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) -{ - die_through_create(dw, die, off, tdp, VOLATILE, "volatile"); -} - -/*ARGSUSED3*/ -static void -die_function_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) -{ - Dwarf_Die arg; - Dwarf_Half tag; - iidesc_t *ii; - char *name; - - debug(3, "die %llu: creating function definition\n", off); - - /* - * We'll begin by processing any type definition nodes that may be - * lurking underneath this one. - */ - for (arg = die_child(dw, die); arg != NULL; - arg = die_sibling(dw, arg)) { - if ((tag = die_tag(dw, arg)) != DW_TAG_formal_parameter && - tag != DW_TAG_variable) { - /* Nested type declaration */ - die_create_one(dw, arg); - } - } - - if (die_isdecl(dw, die) || (name = die_name(dw, die)) == NULL) { - /* - * We process neither prototypes nor subprograms without - * names. - */ - return; - } - - ii = xcalloc(sizeof (iidesc_t)); - ii->ii_type = die_isglobal(dw, die) ? II_GFUN : II_SFUN; - ii->ii_name = name; - if (ii->ii_type == II_SFUN) - ii->ii_owner = xstrdup(dw->dw_cuname); - - debug(3, "die %llu: function %s is %s\n", off, ii->ii_name, - (ii->ii_type == II_GFUN ? "global" : "static")); - - if (die_attr(dw, die, DW_AT_type, 0) != NULL) - ii->ii_dtype = die_lookup_pass1(dw, die, DW_AT_type); - else - ii->ii_dtype = tdesc_intr_void(dw); - - for (arg = die_child(dw, die); arg != NULL; - arg = die_sibling(dw, arg)) { - char *name; - - debug(3, "die %llu: looking at sub member at %llu\n", - off, die_off(dw, die)); - - if (die_tag(dw, arg) != DW_TAG_formal_parameter) - continue; - - if ((name = die_name(dw, arg)) == NULL) { - terminate("die %llu: func arg %d has no name\n", - off, ii->ii_nargs + 1); - } - - if (strcmp(name, "...") == 0) { - free(name); - ii->ii_vargs = 1; - continue; - } - - ii->ii_nargs++; - } - - if (ii->ii_nargs > 0) { - int i; - - debug(3, "die %llu: function has %d argument%s\n", off, - ii->ii_nargs, (ii->ii_nargs == 1 ? "" : "s")); - - ii->ii_args = xcalloc(sizeof (tdesc_t) * ii->ii_nargs); - - for (arg = die_child(dw, die), i = 0; - arg != NULL && i < ii->ii_nargs; - arg = die_sibling(dw, arg)) { - if (die_tag(dw, arg) != DW_TAG_formal_parameter) - continue; - - ii->ii_args[i++] = die_lookup_pass1(dw, arg, - DW_AT_type); - } - } - - iidesc_add(dw->dw_td->td_iihash, ii); -} - -/*ARGSUSED3*/ -static void -die_variable_create(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) -{ - iidesc_t *ii; - char *name; - - debug(3, "die %llu: creating object definition\n", off); - - /* Skip "Non-Defining Declarations" */ - if (die_isdecl(dw, die)) - return; - - /* - * If we find a DIE of "Declarations Completing Non-Defining - * Declarations", we will use the referenced type's DIE. This isn't - * quite correct, e.g. DW_AT_decl_line will be the forward declaration - * not this site. It's sufficient for what we need, however: in - * particular, we should find DW_AT_external as needed there. - */ - if (die_attr(dw, die, DW_AT_specification, 0) != NULL) { - Dwarf_Die sdie; - Dwarf_Off soff; - - soff = die_attr_ref(dw, die, DW_AT_specification); - - if (dwarf_offdie(dw->dw_dw, soff, - &sdie, &dw->dw_err) != DW_DLV_OK) { - terminate("dwarf_offdie(%llu) failed: %s\n", - soff, dwarf_errmsg(dw->dw_err)); - } - - die = sdie; - } - - if ((name = die_name(dw, die)) == NULL) - return; - - ii = xcalloc(sizeof (iidesc_t)); - ii->ii_type = die_isglobal(dw, die) ? II_GVAR : II_SVAR; - ii->ii_name = name; - ii->ii_dtype = die_lookup_pass1(dw, die, DW_AT_type); - if (ii->ii_type == II_SVAR) - ii->ii_owner = xstrdup(dw->dw_cuname); - - iidesc_add(dw->dw_td->td_iihash, ii); -} - -/*ARGSUSED2*/ -static int -die_fwd_resolve(tdesc_t *fwd, tdesc_t **fwdp, void *private) -{ - if (fwd->t_flags & TDESC_F_RESOLVED) - return (1); - - if (fwd->t_tdesc != NULL) { - debug(3, "tdp %u: unforwarded %s\n", fwd->t_id, - tdesc_name(fwd)); - *fwdp = fwd->t_tdesc; - } - - fwd->t_flags |= TDESC_F_RESOLVED; - - return (1); -} - -/*ARGSUSED*/ -static void -die_lexblk_descend(dwarf_t *dw, Dwarf_Die die, Dwarf_Off off, tdesc_t *tdp) -{ - Dwarf_Die child = die_child(dw, die); - - if (child != NULL) - die_create(dw, child); -} - -/* - * Used to map the die to a routine which can parse it, using the tag to do the - * mapping. While the processing of most tags entails the creation of a tdesc, - * there are a few which don't - primarily those which result in the creation of - * iidescs which refer to existing tdescs. - */ - -#define DW_F_NOTDP 0x1 /* Don't create a tdesc for the creator */ - -typedef struct die_creator { - Dwarf_Half dc_tag; - uint16_t dc_flags; - void (*dc_create)(dwarf_t *, Dwarf_Die, Dwarf_Off, tdesc_t *); -} die_creator_t; - -static const die_creator_t die_creators[] = { - { DW_TAG_array_type, 0, die_array_create }, - { DW_TAG_enumeration_type, 0, die_enum_create }, - { DW_TAG_lexical_block, DW_F_NOTDP, die_lexblk_descend }, - { DW_TAG_pointer_type, 0, die_pointer_create }, - { DW_TAG_structure_type, 0, die_struct_create }, - { DW_TAG_subroutine_type, 0, die_funcptr_create }, - { DW_TAG_typedef, 0, die_typedef_create }, - { DW_TAG_union_type, 0, die_union_create }, - { DW_TAG_base_type, 0, die_base_create }, - { DW_TAG_const_type, 0, die_const_create }, - { DW_TAG_subprogram, DW_F_NOTDP, die_function_create }, - { DW_TAG_variable, DW_F_NOTDP, die_variable_create }, - { DW_TAG_volatile_type, 0, die_volatile_create }, - { DW_TAG_restrict_type, 0, die_restrict_create }, - { 0, 0, NULL } -}; - -static const die_creator_t * -die_tag2ctor(Dwarf_Half tag) -{ - const die_creator_t *dc; - - for (dc = die_creators; dc->dc_create != NULL; dc++) { - if (dc->dc_tag == tag) - return (dc); - } - - return (NULL); -} - -static void -die_create_one(dwarf_t *dw, Dwarf_Die die) -{ - Dwarf_Off off = die_off(dw, die); - const die_creator_t *dc; - Dwarf_Half tag; - tdesc_t *tdp; - - debug(3, "die %llu: create_one\n", off); - - if (off > dw->dw_maxoff) { - terminate("illegal die offset %llu (max %llu)\n", off, - dw->dw_maxoff); - } - - tag = die_tag(dw, die); - - if ((dc = die_tag2ctor(tag)) == NULL) { - debug(2, "die %llu: ignoring tag type %x\n", off, tag); - return; - } - - if ((tdp = tdesc_lookup(dw, off)) == NULL && - !(dc->dc_flags & DW_F_NOTDP)) { - tdp = xcalloc(sizeof (tdesc_t)); - tdp->t_id = off; - tdesc_add(dw, tdp); - } - - if (tdp != NULL) - tdp->t_name = die_name(dw, die); - - dc->dc_create(dw, die, off, tdp); -} - -static void -die_create(dwarf_t *dw, Dwarf_Die die) -{ - do { - die_create_one(dw, die); - } while ((die = die_sibling(dw, die)) != NULL); -} - -static tdtrav_cb_f die_resolvers[] = { - NULL, - NULL, /* intrinsic */ - NULL, /* pointer */ - die_array_resolve, /* array */ - NULL, /* function */ - die_sou_resolve, /* struct */ - die_sou_resolve, /* union */ - die_enum_resolve, /* enum */ - die_fwd_resolve, /* forward */ - NULL, /* typedef */ - NULL, /* typedef unres */ - NULL, /* volatile */ - NULL, /* const */ - NULL, /* restrict */ -}; - -static tdtrav_cb_f die_fail_reporters[] = { - NULL, - NULL, /* intrinsic */ - NULL, /* pointer */ - die_array_failed, /* array */ - NULL, /* function */ - die_sou_failed, /* struct */ - die_sou_failed, /* union */ - NULL, /* enum */ - NULL, /* forward */ - NULL, /* typedef */ - NULL, /* typedef unres */ - NULL, /* volatile */ - NULL, /* const */ - NULL, /* restrict */ -}; - -static void -die_resolve(dwarf_t *dw) -{ - int last = -1; - int pass = 0; - - do { - pass++; - dw->dw_nunres = 0; - - (void) iitraverse_hash(dw->dw_td->td_iihash, - &dw->dw_td->td_curvgen, NULL, NULL, die_resolvers, dw); - - debug(3, "resolve: pass %d, %u left\n", pass, dw->dw_nunres); - - if (dw->dw_nunres == last) { - fprintf(stderr, "%s: failed to resolve the following " - "types:\n", progname); - - (void) iitraverse_hash(dw->dw_td->td_iihash, - &dw->dw_td->td_curvgen, NULL, NULL, - die_fail_reporters, dw); - - terminate("failed to resolve types\n"); - } - - last = dw->dw_nunres; - - } while (dw->dw_nunres != 0); -} - -/* - * Any object containing a function or object symbol at any scope should also - * contain DWARF data. - */ -static boolean_t -should_have_dwarf(Elf *elf) -{ - Elf_Scn *scn = NULL; - Elf_Data *data = NULL; - GElf_Shdr shdr; - GElf_Sym sym; - uint32_t symdx = 0; - size_t nsyms = 0; - boolean_t found = B_FALSE; - - while ((scn = elf_nextscn(elf, scn)) != NULL) { - gelf_getshdr(scn, &shdr); - - if (shdr.sh_type == SHT_SYMTAB) { - found = B_TRUE; - break; - } - } - - if (!found) - terminate("cannot convert stripped objects\n"); - - data = elf_getdata(scn, NULL); - nsyms = shdr.sh_size / shdr.sh_entsize; - - for (symdx = 0; symdx < nsyms; symdx++) { - gelf_getsym(data, symdx, &sym); - - if ((GELF_ST_TYPE(sym.st_info) == STT_FUNC) || - (GELF_ST_TYPE(sym.st_info) == STT_TLS) || - (GELF_ST_TYPE(sym.st_info) == STT_OBJECT)) { - char *name; - - name = elf_strptr(elf, shdr.sh_link, sym.st_name); - - /* Studio emits these local symbols regardless */ - if ((strcmp(name, "Bbss.bss") != 0) && - (strcmp(name, "Ttbss.bss") != 0) && - (strcmp(name, "Ddata.data") != 0) && - (strcmp(name, "Ttdata.data") != 0) && - (strcmp(name, "Drodata.rodata") != 0)) - return (B_TRUE); - } - } - - return (B_FALSE); -} - -/*ARGSUSED*/ -int -dw_read(tdata_t *td, Elf *elf, const char *filename) -{ - Dwarf_Unsigned abboff, hdrlen, nxthdr; - Dwarf_Half vers, addrsz; - Dwarf_Die cu, child; - dwarf_t dw; - char *prod = NULL; - int rc; - - bzero(&dw, sizeof (dwarf_t)); - dw.dw_td = td; - dw.dw_ptrsz = elf_ptrsz(elf); - dw.dw_mfgtid_last = TID_MFGTID_BASE; - dw.dw_tidhash = hash_new(TDESC_HASH_BUCKETS, tdesc_idhash, tdesc_idcmp); - dw.dw_fwdhash = hash_new(TDESC_HASH_BUCKETS, tdesc_namehash, - tdesc_namecmp); - dw.dw_enumhash = hash_new(TDESC_HASH_BUCKETS, tdesc_namehash, - tdesc_namecmp); - - if ((rc = dwarf_elf_init(elf, DW_DLC_READ, NULL, NULL, &dw.dw_dw, - &dw.dw_err)) == DW_DLV_NO_ENTRY) { - if (should_have_dwarf(elf)) { - errno = ENOENT; - return (-1); - } else { - return (0); - } - } else if (rc != DW_DLV_OK) { - if (dwarf_errno(dw.dw_err) == DW_DLE_DEBUG_INFO_NULL) { - /* - * There's no type data in the DWARF section, but - * libdwarf is too clever to handle that properly. - */ - return (0); - } - - terminate("failed to initialize DWARF: %s\n", - dwarf_errmsg(dw.dw_err)); - } - - if ((rc = dwarf_next_cu_header(dw.dw_dw, &hdrlen, &vers, &abboff, - &addrsz, &nxthdr, &dw.dw_err)) != DW_DLV_OK) - terminate("file does not contain valid DWARF data: %s\n", - dwarf_errmsg(dw.dw_err)); - - /* - * Some compilers emit no DWARF for empty files, others emit an empty - * compilation unit. - */ - if ((cu = die_sibling(&dw, NULL)) == NULL || - ((child = die_child(&dw, cu)) == NULL) && - should_have_dwarf(elf)) { - terminate("file does not contain dwarf type data " - "(try compiling with -g)\n"); - } else if (child == NULL) { - return (0); - } - - dw.dw_maxoff = nxthdr - 1; - - if (dw.dw_maxoff > TID_FILEMAX) - terminate("file contains too many types\n"); - - debug(1, "DWARF version: %d\n", vers); - if (vers != DWARF_VERSION) { - terminate("file contains incompatible version %d DWARF code " - "(version 2 required)\n", vers); - } - - if (die_string(&dw, cu, DW_AT_producer, &prod, 0)) { - debug(1, "DWARF emitter: %s\n", prod); - free(prod); - } - - if ((dw.dw_cuname = die_name(&dw, cu)) != NULL) { - char *base = xstrdup(basename(dw.dw_cuname)); - free(dw.dw_cuname); - dw.dw_cuname = base; - - debug(1, "CU name: %s\n", dw.dw_cuname); - } - - die_create(&dw, child); - - if ((rc = dwarf_next_cu_header(dw.dw_dw, &hdrlen, &vers, &abboff, - &addrsz, &nxthdr, &dw.dw_err)) != DW_DLV_NO_ENTRY) - terminate("multiple compilation units not supported\n"); - - (void) dwarf_finish(dw.dw_dw, &dw.dw_err); - - die_resolve(&dw); - - cvt_fixups(td, dw.dw_ptrsz); - - /* leak the dwarf_t */ - - return (0); -} |