/*
* Return a boolean value indicating if two types are compatible integers or
* floating-pointer values. This function returns true if the two types are
* the same, or if they have the same ASCII name and encoding properties.
* This function could be extended to test for compatibility for other kinds.
*/
int
ctf_type_compat(ctf_file_t *lfp, ctf_id_t ltype,
ctf_file_t *rfp, ctf_id_t rtype)
{
const ctf_type_t *ltp, *rtp;
ctf_encoding_t le, re;
ctf_arinfo_t la, ra;
uint_t lkind, rkind;
if (ctf_type_cmp(lfp, ltype, rfp, rtype) == 0)
return (1);
ltype = ctf_type_resolve(lfp, ltype);
lkind = ctf_type_kind(lfp, ltype);
rtype = ctf_type_resolve(rfp, rtype);
rkind = ctf_type_kind(rfp, rtype);
if (lkind != rkind ||
(ltp = ctf_lookup_by_id(&lfp, ltype)) == NULL ||
(rtp = ctf_lookup_by_id(&rfp, rtype)) == NULL ||
strcmp(ctf_strptr(lfp, ltp->ctt_name),
ctf_strptr(rfp, rtp->ctt_name)) != 0)
return (0);
switch (lkind) {
case CTF_K_INTEGER:
case CTF_K_FLOAT:
return (ctf_type_encoding(lfp, ltype, &le) == 0 &&
ctf_type_encoding(rfp, rtype, &re) == 0 &&
bcmp(&le, &re, sizeof (ctf_encoding_t)) == 0);
case CTF_K_POINTER:
return (ctf_type_compat(lfp, ctf_type_reference(lfp, ltype),
rfp, ctf_type_reference(rfp, rtype)));
case CTF_K_ARRAY:
return (ctf_array_info(lfp, ltype, &la) == 0 &&
ctf_array_info(rfp, rtype, &ra) == 0 &&
la.ctr_nelems == ra.ctr_nelems && ctf_type_compat(
lfp, la.ctr_contents, rfp, ra.ctr_contents) &&
ctf_type_compat(lfp, la.ctr_index, rfp, ra.ctr_index));
case CTF_K_STRUCT:
case CTF_K_UNION:
return (ctf_type_size(lfp, ltype) == ctf_type_size(rfp, rtype));
case CTF_K_ENUM:
case CTF_K_FORWARD:
return (1); /* no other checks required for these type kinds */
default:
return (0); /* should not get here since we did a resolve */
}
}
ssize_t
mdb_ctf_type_size(mdb_ctf_id_t id)
{
mdb_ctf_impl_t *idp = (mdb_ctf_impl_t *)&id;
ssize_t ret;
/* resolve the type in case there's a forward declaration */
if ((ret = mdb_ctf_type_resolve(id, &id)) != 0)
return (ret);
if ((ret = ctf_type_size(idp->mci_fp, idp->mci_id)) == CTF_ERR)
return (set_errno(ctf_to_errno(ctf_errno(idp->mci_fp))));
return (ret);
}
void
check_sym(ctf_file_t *ctfp, symtab_sym_t *ss)
{
int rettype = ctf_type_kind(ctfp, ss->ss_finfo.ctc_return);
int start_index = 0;
if (ss->ss_finfo.ctc_argc == 0) /* No arguments, no point */
return;
if (((rettype == CTF_K_STRUCT) || (rettype == CTF_K_UNION)) &&
ctf_type_size(ctfp, ss->ss_finfo.ctc_return) > 16)
start_index = 1;
if (saveargs_has_args(ss->ss_data, ss->ss_sym.st_size,
ss->ss_finfo.ctc_argc, start_index) != SAVEARGS_NO_ARGS)
printf("%s has %d saved args\n", ss->ss_name,
ss->ss_finfo.ctc_argc);
}
/*
* Resolve the type down to a base type node, and then return the size
* of the type storage in bytes.
*/
ssize_t
ctf_type_size(ctf_file_t *fp, ctf_id_t type)
{
const ctf_type_t *tp;
ssize_t size;
ctf_arinfo_t ar;
if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
return (-1); /* errno is set for us */
if ((tp = ctf_lookup_by_id(&fp, type)) == NULL)
return (-1); /* errno is set for us */
switch (LCTF_INFO_KIND(fp, tp->ctt_info)) {
case CTF_K_POINTER:
return (fp->ctf_dmodel->ctd_pointer);
case CTF_K_FUNCTION:
return (0); /* function size is only known by symtab */
case CTF_K_ENUM:
return (fp->ctf_dmodel->ctd_int);
case CTF_K_ARRAY:
/*
* Array size is not directly returned by stabs data. Instead,
* it defines the element type and requires the user to perform
* the multiplication. If ctf_get_ctt_size() returns zero, the
* current version of ctfconvert does not compute member sizes
* and we compute the size here on its behalf.
*/
if ((size = ctf_get_ctt_size(fp, tp, NULL, NULL)) > 0)
return (size);
if (ctf_array_info(fp, type, &ar) == CTF_ERR ||
(size = ctf_type_size(fp, ar.ctr_contents)) == CTF_ERR)
return (-1); /* errno is set for us */
return (size * ar.ctr_nelems);
default:
return (ctf_get_ctt_size(fp, tp, NULL, NULL));
}
}
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);
}
int
ctf_add_member(ctf_file_t *fp, ctf_id_t souid, const char *name, ctf_id_t type)
{
ctf_dtdef_t *dtd = ctf_dtd_lookup(fp, souid);
ctf_dmdef_t *dmd;
ssize_t msize, malign, ssize;
uint_t kind, vlen, root;
char *s = NULL;
if (!(fp->ctf_flags & LCTF_RDWR))
return (ctf_set_errno(fp, ECTF_RDONLY));
if (dtd == NULL)
return (ctf_set_errno(fp, ECTF_BADID));
kind = CTF_INFO_KIND(dtd->dtd_data.ctt_info);
root = CTF_INFO_ISROOT(dtd->dtd_data.ctt_info);
vlen = CTF_INFO_VLEN(dtd->dtd_data.ctt_info);
if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
return (ctf_set_errno(fp, ECTF_NOTSOU));
if (vlen == CTF_MAX_VLEN)
return (ctf_set_errno(fp, ECTF_DTFULL));
if (name != NULL) {
for (dmd = ctf_list_next(&dtd->dtd_u.dtu_members);
dmd != NULL; dmd = ctf_list_next(dmd)) {
if (dmd->dmd_name != NULL &&
strcmp(dmd->dmd_name, name) == 0)
return (ctf_set_errno(fp, ECTF_DUPMEMBER));
}
}
if ((msize = ctf_type_size(fp, type)) == CTF_ERR ||
(malign = ctf_type_align(fp, type)) == CTF_ERR)
return (CTF_ERR); /* errno is set for us */
if ((dmd = ctf_alloc(sizeof (ctf_dmdef_t))) == NULL)
return (ctf_set_errno(fp, EAGAIN));
if (name != NULL && (s = ctf_strdup(name)) == NULL) {
ctf_free(dmd, sizeof (ctf_dmdef_t));
return (ctf_set_errno(fp, EAGAIN));
}
dmd->dmd_name = s;
dmd->dmd_type = type;
dmd->dmd_value = -1;
if (kind == CTF_K_STRUCT && vlen != 0) {
ctf_dmdef_t *lmd = ctf_list_prev(&dtd->dtd_u.dtu_members);
ctf_id_t ltype = ctf_type_resolve(fp, lmd->dmd_type);
size_t off = lmd->dmd_offset;
ctf_encoding_t linfo;
ssize_t lsize;
if (ctf_type_encoding(fp, ltype, &linfo) != CTF_ERR)
off += linfo.cte_bits;
else if ((lsize = ctf_type_size(fp, ltype)) != CTF_ERR)
off += lsize * NBBY;
/*
* Round up the offset of the end of the last member to the
* next byte boundary, convert 'off' to bytes, and then round
* it up again to the next multiple of the alignment required
* by the new member. Finally, convert back to bits and store
* the result in dmd_offset. Technically we could do more
* efficient packing if the new member is a bit-field, but
* we're the "compiler" and ANSI says we can do as we choose.
*/
off = roundup(off, NBBY) / NBBY;
off = roundup(off, MAX(malign, 1));
dmd->dmd_offset = off * NBBY;
ssize = off + msize;
} else {
dmd->dmd_offset = 0;
ssize = ctf_get_ctt_size(fp, &dtd->dtd_data, NULL, NULL);
ssize = MAX(ssize, msize);
}
if (ssize > CTF_MAX_SIZE) {
dtd->dtd_data.ctt_size = CTF_LSIZE_SENT;
dtd->dtd_data.ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI(ssize);
dtd->dtd_data.ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO(ssize);
} else
dtd->dtd_data.ctt_size = (ushort_t)ssize;
dtd->dtd_data.ctt_info = CTF_TYPE_INFO(kind, root, vlen + 1);
ctf_list_append(&dtd->dtd_u.dtu_members, dmd);
if (s != NULL)
fp->ctf_dtstrlen += strlen(s) + 1;
ctf_ref_inc(fp, type);
fp->ctf_flags |= LCTF_DIRTY;
return (0);
}
/*
* Exported interface to look up a symbol by name. We return the GElf_Sym and
* complete symbol information for the matching symbol.
*/
int
dtrace_lookup_by_name(dtrace_hdl_t *dtp, const char *object, const char *name,
GElf_Sym *symp, dtrace_syminfo_t *sip)
{
dt_module_t *dmp;
dt_ident_t *idp;
uint_t n, id;
GElf_Sym sym;
uint_t mask = 0; /* mask of dt_module flags to match */
uint_t bits = 0; /* flag bits that must be present */
if (object != DTRACE_OBJ_EVERY &&
object != DTRACE_OBJ_KMODS &&
object != DTRACE_OBJ_UMODS) {
if ((dmp = dt_module_from_object(dtp, object)) == NULL)
return (-1); /* dt_errno is set for us */
if (dt_module_load(dtp, dmp) == -1)
return (-1); /* dt_errno is set for us */
n = 1;
} else {
if (object == DTRACE_OBJ_KMODS)
mask = bits = DT_DM_KERNEL;
else if (object == DTRACE_OBJ_UMODS)
mask = DT_DM_KERNEL;
dmp = dt_list_next(&dtp->dt_modlist);
n = dtp->dt_nmods;
}
if (symp == NULL)
symp = &sym;
for (; n > 0; n--, dmp = dt_list_next(dmp)) {
if ((dmp->dm_flags & mask) != bits)
continue; /* failed to match required attributes */
if (dt_module_load(dtp, dmp) == -1)
continue; /* failed to load symbol table */
if (dmp->dm_ops->do_symname(dmp, name, symp, &id) != NULL) {
if (sip != NULL) {
sip->dts_object = dmp->dm_name;
sip->dts_name = (const char *)
dmp->dm_strtab.cts_data + symp->st_name;
sip->dts_id = id;
}
return (0);
}
if (dmp->dm_extern != NULL &&
(idp = dt_idhash_lookup(dmp->dm_extern, name)) != NULL) {
if (symp != &sym) {
symp->st_name = (uintptr_t)idp->di_name;
symp->st_info =
GELF_ST_INFO(STB_GLOBAL, STT_NOTYPE);
symp->st_other = 0;
symp->st_shndx = SHN_UNDEF;
symp->st_value = 0;
symp->st_size =
ctf_type_size(idp->di_ctfp, idp->di_type);
}
if (sip != NULL) {
sip->dts_object = dmp->dm_name;
sip->dts_name = idp->di_name;
sip->dts_id = idp->di_id;
}
return (0);
}
}
return (dt_set_errno(dtp, EDT_NOSYM));
}
static size_t
dt_idsize_type(dt_ident_t *idp)
{
return (ctf_type_size(idp->di_ctfp, idp->di_type));
}
/*
* Read arguments from the frame indicated by regs into args, return the
* number of arguments successfully read
*/
static int
read_args(struct ps_prochandle *P, uintptr_t fp, uintptr_t pc, prgreg_t *args,
size_t argsize)
{
GElf_Sym sym;
ctf_file_t *ctfp = NULL;
ctf_funcinfo_t finfo;
prsyminfo_t si = {0};
uint8_t ins[SAVEARGS_INSN_SEQ_LEN];
size_t insnsize;
int argc = 0;
int rettype = 0;
int start_index = 0;
int args_style = 0;
int i;
ctf_id_t args_types[5];
if (Pxlookup_by_addr(P, pc, NULL, 0, &sym, &si) != 0)
return (0);
if ((ctfp = Paddr_to_ctf(P, pc)) == NULL)
return (0);
if (ctf_func_info(ctfp, si.prs_id, &finfo) == CTF_ERR)
return (0);
argc = finfo.ctc_argc;
if (argc == 0)
return (0);
rettype = ctf_type_kind(ctfp, finfo.ctc_return);
/*
* If the function returns a structure or union greater than 16 bytes
* in size %rdi contains the address in which to store the return
* value rather than for an argument.
*/
if (((rettype == CTF_K_STRUCT) || (rettype == CTF_K_UNION)) &&
ctf_type_size(ctfp, finfo.ctc_return) > 16)
start_index = 1;
else
start_index = 0;
/*
* If any of the first 5 arguments are a structure less than 16 bytes
* in size, it will be passed spread across two argument registers,
* and we will not cope.
*/
if (ctf_func_args(ctfp, si.prs_id, 5, args_types) == CTF_ERR)
return (0);
for (i = 0; i < MIN(5, finfo.ctc_argc); i++) {
int t = ctf_type_kind(ctfp, args_types[i]);
if (((t == CTF_K_STRUCT) || (t == CTF_K_UNION)) &&
ctf_type_size(ctfp, args_types[i]) <= 16)
return (0);
}
/*
* The number of instructions to search for argument saving is limited
* such that only instructions prior to %pc are considered and we
* never read arguments from a function where the saving code has not
* in fact yet executed.
*/
insnsize = MIN(MIN(sym.st_size, SAVEARGS_INSN_SEQ_LEN),
pc - sym.st_value);
if (Pread(P, ins, insnsize, sym.st_value) != insnsize)
return (0);
if ((argc != 0) &&
((args_style = saveargs_has_args(ins, insnsize, argc,
start_index)) != SAVEARGS_NO_ARGS)) {
int regargs = MIN((6 - start_index), argc);
size_t size = regargs * sizeof (long);
int i;
/*
* If Studio pushed a structure return address as an argument,
* we need to read one more argument than actually exists (the
* addr) to make everything line up.
*/
if (args_style == SAVEARGS_STRUCT_ARGS)
size += sizeof (long);
if (Pread(P, args, size, (fp - size)) != size)
return (0);
for (i = 0; i < (regargs / 2); i++) {
prgreg_t t = args[i];
args[i] = args[regargs - i - 1];
args[regargs - i - 1] = t;
}
if (argc > regargs) {
size = MIN((argc - regargs) * sizeof (long),
argsize - (regargs * sizeof (long)));
if (Pread(P, &args[regargs], size, fp +
(sizeof (uintptr_t) * 2)) != size)
return (6);
}
return (argc);
} else {
return (0);
}
}
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;
}
}
