int
mdb_ctf_member_iter(mdb_ctf_id_t id, mdb_ctf_member_f *cb, void *data)
{
mdb_ctf_impl_t *idp = (mdb_ctf_impl_t *)&id;
member_iter_t mi;
int ret;
/* resolve the type in case there's a forward declaration */
if ((ret = mdb_ctf_type_resolve(id, &id)) != 0)
return (ret);
mi.mi_cb = cb;
mi.mi_arg = data;
mi.mi_fp = idp->mci_fp;
ret = ctf_member_iter(idp->mci_fp, idp->mci_id, member_iter_cb, &mi);
if (ret == CTF_ERR)
return (set_errno(ctf_to_errno(ctf_errno(idp->mci_fp))));
return (ret);
}
static int
ctfdump_types_cb(ctf_id_t id, boolean_t root, void *arg)
{
int kind, i, count;
ctf_id_t ref;
char name[512], ienc[128];
const char *encn;
ctf_funcinfo_t ctc;
ctf_arinfo_t ar;
ctf_encoding_t cte;
ssize_t size;
if ((kind = ctf_type_kind(g_fp, id)) == CTF_ERR)
ctfdump_fatal("encountered malformed ctf, type %s does not "
"have a kind: %s\n", name, ctf_errmsg(ctf_errno(g_fp)));
if (ctf_type_name(g_fp, id, name, sizeof (name)) == NULL) {
if (ctf_errno(g_fp) != ECTF_NOPARENT)
ctfdump_fatal("type %lu missing name: %s\n", id,
ctf_errmsg(ctf_errno(g_fp)));
(void) snprintf(name, sizeof (name), "(unknown %s)",
ctf_kind_name(g_fp, kind));
}
g_stats.cs_ntypes[kind]++;
if (root == B_TRUE)
ctfdump_printf(CTFDUMP_TYPES, " <%lu> ", id);
else
ctfdump_printf(CTFDUMP_TYPES, " [%lu] ", id);
switch (kind) {
case CTF_K_UNKNOWN:
break;
case CTF_K_INTEGER:
if (ctf_type_encoding(g_fp, id, &cte) == CTF_ERR)
ctfdump_fatal("failed to get encoding information "
"for %s: %s\n", name, ctf_errmsg(ctf_errno(g_fp)));
ctfdump_intenc_name(&cte, ienc, sizeof (ienc));
ctfdump_printf(CTFDUMP_TYPES,
"%s encoding=%s offset=%u bits=%u",
name, ienc, cte.cte_offset, cte.cte_bits);
break;
case CTF_K_FLOAT:
if (ctf_type_encoding(g_fp, id, &cte) == CTF_ERR)
ctfdump_fatal("failed to get encoding information "
"for %s: %s\n", name, ctf_errmsg(ctf_errno(g_fp)));
if (cte.cte_format < 1 || cte.cte_format > 12)
encn = "unknown";
else
encn = ctfdump_fpenc[cte.cte_format];
ctfdump_printf(CTFDUMP_TYPES, "%s encoding=%s offset=%u "
"bits=%u", name, encn, cte.cte_offset, cte.cte_bits);
break;
case CTF_K_POINTER:
if ((ref = ctf_type_reference(g_fp, id)) == CTF_ERR)
ctfdump_fatal("failed to get reference type for %s: "
"%s\n", name, ctf_errmsg(ctf_errno(g_fp)));
ctfdump_printf(CTFDUMP_TYPES, "%s refers to %lu", name,
ref);
break;
case CTF_K_ARRAY:
if (ctf_array_info(g_fp, id, &ar) == CTF_ERR)
ctfdump_fatal("failed to get array information for "
"%s: %s\n", name, ctf_errmsg(ctf_errno(g_fp)));
ctfdump_printf(CTFDUMP_TYPES, "%s contents: %lu, index: %lu",
name, ar.ctr_contents, ar.ctr_index);
break;
case CTF_K_FUNCTION:
if (ctf_func_info_by_id(g_fp, id, &ctc) == CTF_ERR)
ctfdump_fatal("failed to get function info for %s: "
"%s\n", name, ctf_errmsg(ctf_errno(g_fp)));
if (ctc.ctc_argc > 0) {
ctfdump_fargs_grow(ctc.ctc_argc);
if (ctf_func_args_by_id(g_fp, id, g_nfargc, g_fargc) ==
CTF_ERR)
ctfdump_fatal("failed to get function "
"arguments for %s: %s\n", name,
ctf_errmsg(ctf_errno(g_fp)));
}
ctfdump_printf(CTFDUMP_TYPES,
"%s returns: %lu args: (", name, ctc.ctc_return);
for (i = 0; i < ctc.ctc_argc; i++) {
ctfdump_printf(CTFDUMP_TYPES, "%lu%s", g_fargc[i],
i + 1 == ctc.ctc_argc ? "" : ", ");
}
if (ctc.ctc_flags & CTF_FUNC_VARARG)
ctfdump_printf(CTFDUMP_TYPES, "%s...",
ctc.ctc_argc == 0 ? "" : ", ");
ctfdump_printf(CTFDUMP_TYPES, ")");
break;
case CTF_K_STRUCT:
case CTF_K_UNION:
size = ctf_type_size(g_fp, id);
if (size == CTF_ERR)
ctfdump_fatal("failed to get size of %s: %s\n", name,
ctf_errmsg(ctf_errno(g_fp)));
ctfdump_printf(CTFDUMP_TYPES, "%s (%d bytes)\n", name, size);
count = 0;
if (ctf_member_iter(g_fp, id, ctfdump_member_cb, &count) != 0)
ctfdump_fatal("failed to iterate members of %s: %s\n",
name, ctf_errmsg(ctf_errno(g_fp)));
if (kind == CTF_K_STRUCT) {
g_stats.cs_nsmembs += count;
g_stats.cs_nsmax = MAX(count, g_stats.cs_nsmax);
g_stats.cs_structsz += size;
g_stats.cs_sszmax = MAX(size, g_stats.cs_sszmax);
} else {
g_stats.cs_numembs += count;
g_stats.cs_numax = MAX(count, g_stats.cs_numax);
g_stats.cs_unionsz += size;
g_stats.cs_uszmax = MAX(count, g_stats.cs_uszmax);
}
break;
case CTF_K_ENUM:
ctfdump_printf(CTFDUMP_TYPES, "%s\n", name);
count = 0;
if (ctf_enum_iter(g_fp, id, ctfdump_enum_cb, &count) != 0)
ctfdump_fatal("failed to iterate enumerators of %s: "
"%s\n", name, ctf_errmsg(ctf_errno(g_fp)));
g_stats.cs_nemembs += count;
g_stats.cs_nemax = MAX(g_stats.cs_nemax, count);
break;
case CTF_K_FORWARD:
ctfdump_printf(CTFDUMP_TYPES, "forward %s\n", name);
break;
case CTF_K_TYPEDEF:
if ((ref = ctf_type_reference(g_fp, id)) == CTF_ERR)
ctfdump_fatal("failed to get reference type for %s: "
"%s\n", name, ctf_errmsg(ctf_errno(g_fp)));
ctfdump_printf(CTFDUMP_TYPES, "typedef %s refers to %lu", name,
ref);
break;
case CTF_K_VOLATILE:
if ((ref = ctf_type_reference(g_fp, id)) == CTF_ERR)
ctfdump_fatal("failed to get reference type for %s: "
"%s\n", name, ctf_errmsg(ctf_errno(g_fp)));
ctfdump_printf(CTFDUMP_TYPES, "%s refers to %lu", name,
ref);
break;
case CTF_K_CONST:
if ((ref = ctf_type_reference(g_fp, id)) == CTF_ERR)
ctfdump_fatal("failed to get reference type for %s: "
"%s\n", name, ctf_errmsg(ctf_errno(g_fp)));
ctfdump_printf(CTFDUMP_TYPES, "%s refers to %lu", name,
ref);
break;
case CTF_K_RESTRICT:
if ((ref = ctf_type_reference(g_fp, id)) == CTF_ERR)
ctfdump_fatal("failed to get reference type for %s: "
"%s\n", name, ctf_errmsg(ctf_errno(g_fp)));
ctfdump_printf(CTFDUMP_TYPES, "%s refers to %lu", name,
ref);
break;
default:
ctfdump_fatal("encountered unknown kind for type %s: %d\n",
name, kind);
}
ctfdump_printf(CTFDUMP_TYPES, "\n");
return (0);
}
/*
* The ctf_add_type routine is used to copy a type from a source CTF container
* to a dynamic destination container. This routine operates recursively by
* following the source type's links and embedded member types. If the
* destination container already contains a named type which has the same
* attributes, then we succeed and return this type but no changes occur.
*/
ctf_id_t
ctf_add_type(ctf_file_t *dst_fp, ctf_file_t *src_fp, ctf_id_t src_type)
{
ctf_id_t dst_type = CTF_ERR;
uint_t dst_kind = CTF_K_UNKNOWN;
const ctf_type_t *tp;
const char *name;
uint_t kind, flag, vlen;
ctf_bundle_t src, dst;
ctf_encoding_t src_en, dst_en;
ctf_arinfo_t src_ar, dst_ar;
ctf_dtdef_t *dtd;
ctf_funcinfo_t ctc;
ssize_t size;
ctf_hash_t *hp;
ctf_helem_t *hep;
if (dst_fp == src_fp)
return (src_type);
if (!(dst_fp->ctf_flags & LCTF_RDWR))
return (ctf_set_errno(dst_fp, ECTF_RDONLY));
if ((tp = ctf_lookup_by_id(&src_fp, src_type)) == NULL)
return (ctf_set_errno(dst_fp, ctf_errno(src_fp)));
name = ctf_strptr(src_fp, tp->ctt_name);
kind = LCTF_INFO_KIND(src_fp, tp->ctt_info);
flag = LCTF_INFO_ROOT(src_fp, tp->ctt_info);
vlen = LCTF_INFO_VLEN(src_fp, tp->ctt_info);
switch (kind) {
case CTF_K_STRUCT:
hp = &dst_fp->ctf_structs;
break;
case CTF_K_UNION:
hp = &dst_fp->ctf_unions;
break;
case CTF_K_ENUM:
hp = &dst_fp->ctf_enums;
break;
default:
hp = &dst_fp->ctf_names;
break;
}
/*
* If the source type has a name and is a root type (visible at the
* top-level scope), lookup the name in the destination container and
* verify that it is of the same kind before we do anything else.
*/
if ((flag & CTF_ADD_ROOT) && name[0] != '\0' &&
(hep = ctf_hash_lookup(hp, dst_fp, name, strlen(name))) != NULL) {
dst_type = (ctf_id_t)hep->h_type;
dst_kind = ctf_type_kind(dst_fp, dst_type);
}
/*
* If an identically named dst_type exists, fail with ECTF_CONFLICT
* unless dst_type is a forward declaration and src_type is a struct,
* union, or enum (i.e. the definition of the previous forward decl).
*/
if (dst_type != CTF_ERR && dst_kind != kind) {
if (dst_kind != CTF_K_FORWARD || (kind != CTF_K_ENUM &&
kind != CTF_K_STRUCT && kind != CTF_K_UNION))
return (ctf_set_errno(dst_fp, ECTF_CONFLICT));
else
dst_type = CTF_ERR;
}
/*
* If the non-empty name was not found in the appropriate hash, search
* the list of pending dynamic definitions that are not yet committed.
* If a matching name and kind are found, assume this is the type that
* we are looking for. This is necessary to permit ctf_add_type() to
* operate recursively on entities such as a struct that contains a
* pointer member that refers to the same struct type.
*
* In the case of integer and floating point types, we match using the
* type encoding as well - else we may incorrectly return a bitfield
* type, for instance.
*/
if (dst_type == CTF_ERR && name[0] != '\0') {
for (dtd = ctf_list_prev(&dst_fp->ctf_dtdefs); dtd != NULL &&
CTF_TYPE_TO_INDEX(dtd->dtd_type) > dst_fp->ctf_dtoldid;
dtd = ctf_list_prev(dtd)) {
if (CTF_INFO_KIND(dtd->dtd_data.ctt_info) != kind ||
dtd->dtd_name == NULL ||
strcmp(dtd->dtd_name, name) != 0)
continue;
if (kind == CTF_K_INTEGER || kind == CTF_K_FLOAT) {
if (ctf_type_encoding(src_fp, src_type,
&src_en) != 0)
continue;
if (bcmp(&src_en, &dtd->dtd_u.dtu_enc,
sizeof (ctf_encoding_t)) != 0)
continue;
}
return (dtd->dtd_type);
}
}
src.ctb_file = src_fp;
src.ctb_type = src_type;
src.ctb_dtd = NULL;
dst.ctb_file = dst_fp;
dst.ctb_type = dst_type;
dst.ctb_dtd = NULL;
/*
* Now perform kind-specific processing. If dst_type is CTF_ERR, then
* we add a new type with the same properties as src_type to dst_fp.
* If dst_type is not CTF_ERR, then we verify that dst_type has the
* same attributes as src_type. We recurse for embedded references.
*/
switch (kind) {
case CTF_K_INTEGER:
case CTF_K_FLOAT:
if (ctf_type_encoding(src_fp, src_type, &src_en) != 0)
return (ctf_set_errno(dst_fp, ctf_errno(src_fp)));
if (dst_type != CTF_ERR) {
if (ctf_type_encoding(dst_fp, dst_type, &dst_en) != 0)
return (CTF_ERR); /* errno is set for us */
if (bcmp(&src_en, &dst_en, sizeof (ctf_encoding_t)))
return (ctf_set_errno(dst_fp, ECTF_CONFLICT));
} else if (kind == CTF_K_INTEGER) {
dst_type = ctf_add_integer(dst_fp, flag, name, &src_en);
} else
dst_type = ctf_add_float(dst_fp, flag, name, &src_en);
break;
case CTF_K_POINTER:
case CTF_K_VOLATILE:
case CTF_K_CONST:
case CTF_K_RESTRICT:
src_type = ctf_type_reference(src_fp, src_type);
src_type = ctf_add_type(dst_fp, src_fp, src_type);
if (src_type == CTF_ERR)
return (CTF_ERR); /* errno is set for us */
dst_type = ctf_add_reftype(dst_fp, flag, src_type, kind);
break;
case CTF_K_ARRAY:
if (ctf_array_info(src_fp, src_type, &src_ar) == CTF_ERR)
return (ctf_set_errno(dst_fp, ctf_errno(src_fp)));
src_ar.ctr_contents =
ctf_add_type(dst_fp, src_fp, src_ar.ctr_contents);
src_ar.ctr_index =
ctf_add_type(dst_fp, src_fp, src_ar.ctr_index);
src_ar.ctr_nelems = src_ar.ctr_nelems;
if (src_ar.ctr_contents == CTF_ERR ||
src_ar.ctr_index == CTF_ERR)
return (CTF_ERR); /* errno is set for us */
if (dst_type != CTF_ERR) {
if (ctf_array_info(dst_fp, dst_type, &dst_ar) != 0)
return (CTF_ERR); /* errno is set for us */
if (bcmp(&src_ar, &dst_ar, sizeof (ctf_arinfo_t)))
return (ctf_set_errno(dst_fp, ECTF_CONFLICT));
} else
dst_type = ctf_add_array(dst_fp, flag, &src_ar);
break;
case CTF_K_FUNCTION:
ctc.ctc_return = ctf_add_type(dst_fp, src_fp, tp->ctt_type);
ctc.ctc_argc = 0;
ctc.ctc_flags = 0;
if (ctc.ctc_return == CTF_ERR)
return (CTF_ERR); /* errno is set for us */
dst_type = ctf_add_function(dst_fp, flag, &ctc, NULL);
break;
case CTF_K_STRUCT:
case CTF_K_UNION: {
ctf_dmdef_t *dmd;
int errs = 0;
/*
* Technically to match a struct or union we need to check both
* ways (src members vs. dst, dst members vs. src) but we make
* this more optimal by only checking src vs. dst and comparing
* the total size of the structure (which we must do anyway)
* which covers the possibility of dst members not in src.
* This optimization can be defeated for unions, but is so
* pathological as to render it irrelevant for our purposes.
*/
if (dst_type != CTF_ERR && dst_kind != CTF_K_FORWARD) {
if (ctf_type_size(src_fp, src_type) !=
ctf_type_size(dst_fp, dst_type))
return (ctf_set_errno(dst_fp, ECTF_CONFLICT));
if (ctf_member_iter(src_fp, src_type, membcmp, &dst))
return (ctf_set_errno(dst_fp, ECTF_CONFLICT));
break;
}
/*
* Unlike the other cases, copying structs and unions is done
* manually so as to avoid repeated lookups in ctf_add_member
* and to ensure the exact same member offsets as in src_type.
*/
dst_type = ctf_add_generic(dst_fp, flag, name, &dtd);
if (dst_type == CTF_ERR)
return (CTF_ERR); /* errno is set for us */
dst.ctb_type = dst_type;
dst.ctb_dtd = dtd;
if (ctf_member_iter(src_fp, src_type, membadd, &dst) != 0)
errs++; /* increment errs and fail at bottom of case */
if ((size = ctf_type_size(src_fp, src_type)) > CTF_MAX_SIZE) {
dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI(size);
dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO(size);
} else
dtd->dtd_data.ctt_size = (ushort_t)size;
dtd->dtd_data.ctt_info = CTF_TYPE_INFO(kind, flag, vlen);
/*
* Make a final pass through the members changing each dmd_type
* (a src_fp type) to an equivalent type in dst_fp. We pass
* through all members, leaving any that fail set to CTF_ERR.
*/
for (dmd = ctf_list_next(&dtd->dtd_u.dtu_members);
dmd != NULL; dmd = ctf_list_next(dmd)) {
if ((dmd->dmd_type = ctf_add_type(dst_fp, src_fp,
dmd->dmd_type)) == CTF_ERR)
errs++;
}
if (errs)
return (CTF_ERR); /* errno is set for us */
/*
* Now that we know that we can't fail, we go through and bump
* all the reference counts on the member types.
*/
for (dmd = ctf_list_next(&dtd->dtd_u.dtu_members);
dmd != NULL; dmd = ctf_list_next(dmd))
ctf_ref_inc(dst_fp, dmd->dmd_type);
break;
}
case CTF_K_ENUM:
if (dst_type != CTF_ERR && dst_kind != CTF_K_FORWARD) {
if (ctf_enum_iter(src_fp, src_type, enumcmp, &dst) ||
ctf_enum_iter(dst_fp, dst_type, enumcmp, &src))
return (ctf_set_errno(dst_fp, ECTF_CONFLICT));
} else {
dst_type = ctf_add_enum(dst_fp, flag, name);
if ((dst.ctb_type = dst_type) == CTF_ERR ||
ctf_enum_iter(src_fp, src_type, enumadd, &dst))
return (CTF_ERR); /* errno is set for us */
}
break;
case CTF_K_FORWARD:
if (dst_type == CTF_ERR) {
dst_type = ctf_add_forward(dst_fp,
flag, name, CTF_K_STRUCT); /* assume STRUCT */
}
break;
case CTF_K_TYPEDEF:
src_type = ctf_type_reference(src_fp, src_type);
src_type = ctf_add_type(dst_fp, src_fp, src_type);
if (src_type == CTF_ERR)
return (CTF_ERR); /* errno is set for us */
/*
* If dst_type is not CTF_ERR at this point, we should check if
* ctf_type_reference(dst_fp, dst_type) != src_type and if so
* fail with ECTF_CONFLICT. However, this causes problems with
* <sys/types.h> typedefs that vary based on things like if
* _ILP32x then pid_t is int otherwise long. We therefore omit
* this check and assume that if the identically named typedef
* already exists in dst_fp, it is correct or equivalent.
*/
if (dst_type == CTF_ERR) {
dst_type = ctf_add_typedef(dst_fp, flag,
name, src_type);
}
break;
default:
return (ctf_set_errno(dst_fp, ECTF_CORRUPT));
}
return (dst_type);
}
dt_xlator_t *
dt_xlator_create(dtrace_hdl_t *dtp,
const dtrace_typeinfo_t *src, const dtrace_typeinfo_t *dst,
const char *name, dt_node_t *members, dt_node_t *nodes)
{
dt_xlator_t *dxp = dt_zalloc(dtp, sizeof (dt_xlator_t));
dtrace_typeinfo_t ptr = *dst;
dt_xlator_t **map;
dt_node_t *dnp;
uint_t kind;
if (dxp == NULL)
return (NULL);
dxp->dx_hdl = dtp;
dxp->dx_id = dtp->dt_xlatorid++;
dxp->dx_gen = dtp->dt_gen;
dxp->dx_arg = -1;
if ((map = dt_alloc(dtp, sizeof (void *) * (dxp->dx_id + 1))) == NULL) {
dt_free(dtp, dxp);
return (NULL);
}
dt_list_append(&dtp->dt_xlators, dxp);
bcopy(dtp->dt_xlatormap, map, sizeof (void *) * dxp->dx_id);
dt_free(dtp, dtp->dt_xlatormap);
dtp->dt_xlatormap = map;
dtp->dt_xlatormap[dxp->dx_id] = dxp;
if (dt_type_pointer(&ptr) == -1) {
ptr.dtt_ctfp = NULL;
ptr.dtt_type = CTF_ERR;
}
dxp->dx_ident = dt_ident_create(name ? name : "T",
DT_IDENT_SCALAR, DT_IDFLG_REF | DT_IDFLG_ORPHAN, 0,
_dtrace_defattr, 0, &dt_idops_thaw, NULL, dtp->dt_gen);
if (dxp->dx_ident == NULL)
goto err; /* no memory for identifier */
dxp->dx_ident->di_ctfp = src->dtt_ctfp;
dxp->dx_ident->di_type = src->dtt_type;
/*
* If an input parameter name is given, this is a static translator
* definition: create an idhash and identifier for the parameter.
*/
if (name != NULL) {
dxp->dx_locals = dt_idhash_create("xlparams", NULL, 0, 0);
if (dxp->dx_locals == NULL)
goto err; /* no memory for identifier hash */
dt_idhash_xinsert(dxp->dx_locals, dxp->dx_ident);
}
dxp->dx_souid.di_name = "translator";
dxp->dx_souid.di_kind = DT_IDENT_XLSOU;
dxp->dx_souid.di_flags = DT_IDFLG_REF;
dxp->dx_souid.di_id = dxp->dx_id;
dxp->dx_souid.di_attr = _dtrace_defattr;
dxp->dx_souid.di_ops = &dt_idops_thaw;
dxp->dx_souid.di_data = dxp;
dxp->dx_souid.di_ctfp = dst->dtt_ctfp;
dxp->dx_souid.di_type = dst->dtt_type;
dxp->dx_souid.di_gen = dtp->dt_gen;
dxp->dx_ptrid.di_name = "translator";
dxp->dx_ptrid.di_kind = DT_IDENT_XLPTR;
dxp->dx_ptrid.di_flags = DT_IDFLG_REF;
dxp->dx_ptrid.di_id = dxp->dx_id;
dxp->dx_ptrid.di_attr = _dtrace_defattr;
dxp->dx_ptrid.di_ops = &dt_idops_thaw;
dxp->dx_ptrid.di_data = dxp;
dxp->dx_ptrid.di_ctfp = ptr.dtt_ctfp;
dxp->dx_ptrid.di_type = ptr.dtt_type;
dxp->dx_ptrid.di_gen = dtp->dt_gen;
/*
* If a deferred pragma is pending on the keyword "translator", run all
* the deferred pragmas on dx_souid and then copy results to dx_ptrid.
* See the code in dt_pragma.c for details on deferred ident pragmas.
*/
if (dtp->dt_globals->dh_defer != NULL && yypcb->pcb_pragmas != NULL &&
dt_idhash_lookup(yypcb->pcb_pragmas, "translator") != NULL) {
dtp->dt_globals->dh_defer(dtp->dt_globals, &dxp->dx_souid);
dxp->dx_ptrid.di_attr = dxp->dx_souid.di_attr;
dxp->dx_ptrid.di_vers = dxp->dx_souid.di_vers;
}
dxp->dx_src_ctfp = src->dtt_ctfp;
dxp->dx_src_type = src->dtt_type;
dxp->dx_src_base = ctf_type_resolve(src->dtt_ctfp, src->dtt_type);
dxp->dx_dst_ctfp = dst->dtt_ctfp;
dxp->dx_dst_type = dst->dtt_type;
dxp->dx_dst_base = ctf_type_resolve(dst->dtt_ctfp, dst->dtt_type);
kind = ctf_type_kind(dst->dtt_ctfp, dxp->dx_dst_base);
assert(kind == CTF_K_STRUCT || kind == CTF_K_UNION);
/*
* If no input parameter is given, we're making a dynamic translator:
* create member nodes for every member of the output type. Otherwise
* retain the member and allocation node lists presented by the parser.
*/
if (name == NULL) {
if (ctf_member_iter(dxp->dx_dst_ctfp, dxp->dx_dst_base,
dt_xlator_create_member, dxp) != 0)
goto err;
} else {
dxp->dx_members = members;
dxp->dx_nodes = nodes;
}
/*
* Assign member IDs to each member and allocate space for DIFOs
* if and when this translator is eventually compiled.
*/
for (dnp = dxp->dx_members; dnp != NULL; dnp = dnp->dn_list) {
dnp->dn_membxlator = dxp;
dnp->dn_membid = dxp->dx_nmembers++;
}
dxp->dx_membdif = dt_zalloc(dtp,
sizeof (dtrace_difo_t *) * dxp->dx_nmembers);
if (dxp->dx_membdif == NULL) {
dxp->dx_nmembers = 0;
goto err;
}
return (dxp);
err:
dt_xlator_destroy(dtp, dxp);
return (NULL);
}
/* find the tid of a specified member */
static ctf_id_t
find_member(ctf_id_t tid, char *memname)
{
return (ctf_member_iter(ctf, tid, find_member_cb, memname));
}
static void
ctfsrc_type(ctf_id_t id, const char *name)
{
char refname[MAX_NAMELEN];
ctf_id_t ref;
ssize_t size;
int kind;
if ((kind = ctf_type_kind(g_fp, id)) == CTF_ERR) {
ctfdump_fatal("encountered malformed ctf, type %s does not "
"have a kind: %s\n", name, ctf_errmsg(ctf_errno(g_fp)));
}
switch (kind) {
case CTF_K_STRUCT:
case CTF_K_UNION:
/*
* Delay printing anonymous SOUs; a later typedef will usually
* pick them up.
*/
if (is_anon_refname(name))
break;
if ((size = ctf_type_size(g_fp, id)) == CTF_ERR) {
ctfdump_fatal("failed to get size of %s: %s\n", name,
ctf_errmsg(ctf_errno(g_fp)));
}
(void) printf("%s { /* 0x%x bytes */\n", name, size);
if (ctf_member_iter(g_fp, id, ctfsrc_member_cb, NULL) != 0) {
ctfdump_fatal("failed to iterate members of %s: %s\n",
name, ctf_errmsg(ctf_errno(g_fp)));
}
(void) printf("};\n\n");
break;
case CTF_K_ENUM:
/*
* This will throw away any anon enum that isn't followed by a
* typedef...
*/
if (is_anon_refname(name))
break;
(void) printf("%s {\n", name);
if (ctf_enum_iter(g_fp, id, ctfsrc_enum_cb, NULL) != 0) {
ctfdump_fatal("failed to iterate enumerators of %s: "
"%s\n", name, ctf_errmsg(ctf_errno(g_fp)));
}
(void) printf("};\n\n");
break;
case CTF_K_TYPEDEF:
ctfsrc_refname(id, refname, sizeof (refname));
if (!is_anon_refname(refname)) {
(void) ctf_type_cname(g_fp,
ctf_type_reference(g_fp, id), refname,
sizeof (refname), name);
(void) printf("typedef %s;\n\n", refname);
break;
}
ref = ctf_type_reference(g_fp, id);
if (ctf_type_kind(g_fp, ref) == CTF_K_ENUM) {
(void) printf("typedef enum {\n");
if (ctf_enum_iter(g_fp, ref,
ctfsrc_enum_cb, NULL) != 0) {
ctfdump_fatal("failed to iterate enumerators "
"of %s: %s\n", refname,
ctf_errmsg(ctf_errno(g_fp)));
}
(void) printf("} %s;\n\n", name);
} else {
if ((size = ctf_type_size(g_fp, ref)) == CTF_ERR) {
ctfdump_fatal("failed to get size of %s: %s\n",
refname, ctf_errmsg(ctf_errno(g_fp)));
}
(void) printf("typedef %s{ /* 0x%zx bytes */\n",
refname, size);
if (ctf_member_iter(g_fp, ref,
ctfsrc_member_cb, NULL) != 0) {
ctfdump_fatal("failed to iterate members "
"of %s: %s\n", refname,
ctf_errmsg(ctf_errno(g_fp)));
}
(void) printf("} %s;\n\n", name);
}
break;
case CTF_K_FORWARD:
(void) printf("%s;\n\n", name);
break;
case CTF_K_UNKNOWN:
case CTF_K_INTEGER:
case CTF_K_FLOAT:
case CTF_K_POINTER:
case CTF_K_ARRAY:
case CTF_K_FUNCTION:
case CTF_K_VOLATILE:
case CTF_K_CONST:
case CTF_K_RESTRICT:
break;
default:
ctfdump_fatal("encountered unknown kind for type %s: %d\n",
name, kind);
break;
}
}