/*
* Find a pointer to type by looking in fp->ctf_ptrtab. If we can't find a
* pointer to the given type, see if we can compute a pointer to the type
* resulting from resolving the type down to its base type and use that
* instead. This helps with cases where the CTF data includes "struct foo *"
* but not "foo_t *" and the user accesses "foo_t *" in the debugger.
*/
ctf_id_t
ctf_type_pointer(ctf_file_t *fp, ctf_id_t type)
{
ctf_file_t *ofp = fp;
ctf_id_t ntype;
if (ctf_lookup_by_id(&fp, type) == NULL)
return (CTF_ERR); /* errno is set for us */
if ((ntype = fp->ctf_ptrtab[CTF_TYPE_TO_INDEX(type)]) != 0)
return (CTF_INDEX_TO_TYPE(ntype, (fp->ctf_flags & LCTF_CHILD)));
if ((type = ctf_type_resolve(fp, type)) == CTF_ERR)
return (ctf_set_errno(ofp, ECTF_NOTYPE));
if (ctf_lookup_by_id(&fp, type) == NULL)
return (ctf_set_errno(ofp, ECTF_NOTYPE));
if ((ntype = fp->ctf_ptrtab[CTF_TYPE_TO_INDEX(type)]) != 0)
return (CTF_INDEX_TO_TYPE(ntype, (fp->ctf_flags & LCTF_CHILD)));
return (ctf_set_errno(ofp, ECTF_NOTYPE));
}
/*
* Return the pointer to the internal CTF type data corresponding to the
* given type ID. If the ID is invalid, the function returns NULL.
* This function is not exported outside of the library.
*/
const ctf_type_t *
ctf_lookup_by_id(ctf_file_t **fpp, ctf_id_t type)
{
ctf_file_t *fp = *fpp; /* caller passes in starting CTF container */
if ((fp->ctf_flags & LCTF_CHILD) && CTF_TYPE_ISPARENT(type) &&
(fp = fp->ctf_parent) == NULL) {
(void) ctf_set_errno(*fpp, ECTF_NOPARENT);
return (NULL);
}
type = CTF_TYPE_TO_INDEX(type);
if (type > 0 && type <= fp->ctf_typemax) {
*fpp = fp; /* function returns ending CTF container */
return (LCTF_INDEX_TO_TYPEPTR(fp, type));
}
(void) ctf_set_errno(fp, ECTF_BADID);
return (NULL);
}
/*
* Discard all of the dynamic type definitions that have been added to the
* container since the last call to ctf_update(). We locate such types by
* scanning the list and deleting elements that have type IDs greater than
* ctf_dtoldid, which is set by ctf_update(), above. Note that to work properly
* with our reference counting schemes, we must delete the dynamic list in
* reverse.
*/
int
ctf_discard(ctf_file_t *fp)
{
ctf_dtdef_t *dtd, *ntd;
if (!(fp->ctf_flags & LCTF_RDWR))
return (ctf_set_errno(fp, ECTF_RDONLY));
if (!(fp->ctf_flags & LCTF_DIRTY))
return (0); /* no update required */
for (dtd = ctf_list_prev(&fp->ctf_dtdefs); dtd != NULL; dtd = ntd) {
ntd = ctf_list_prev(dtd);
if (CTF_TYPE_TO_INDEX(dtd->dtd_type) <= fp->ctf_dtoldid)
continue; /* skip types that have been committed */
ctf_dtd_delete(fp, dtd);
}
fp->ctf_dtnextid = fp->ctf_dtoldid + 1;
fp->ctf_flags &= ~LCTF_DIRTY;
return (0);
}
/*
* Initialize the type ID translation table with the byte offset of each type,
* and initialize the hash tables of each named type.
*/
static int
init_types(ctf_file_t *fp, const ctf_header_t *cth)
{
/* LINTED - pointer alignment */
const ctf_type_t *tbuf = (ctf_type_t *)(fp->ctf_buf + cth->cth_typeoff);
/* LINTED - pointer alignment */
const ctf_type_t *tend = (ctf_type_t *)(fp->ctf_buf + cth->cth_stroff);
ulong_t pop[CTF_K_MAX + 1] = { 0 };
const ctf_type_t *tp;
ctf_hash_t *hp;
ushort_t dst;
ctf_id_t id;
uint_t *xp;
/*
* We initially determine whether the container is a child or a parent
* based on the value of cth_parname. To support containers that pre-
* date cth_parname, we also scan the types themselves for references
* to values in the range reserved for child types in our first pass.
*/
int child = cth->cth_parname != 0;
int nlstructs = 0, nlunions = 0;
int err;
/*
* We make two passes through the entire type section. In this first
* pass, we count the number of each type and the total number of types.
*/
for (tp = tbuf; tp < tend; fp->ctf_typemax++) {
ushort_t kind = LCTF_INFO_KIND(fp, tp->ctt_info);
ulong_t vlen = LCTF_INFO_VLEN(fp, tp->ctt_info);
ssize_t size, increment;
size_t vbytes;
uint_t n;
(void) ctf_get_ctt_size(fp, tp, &size, &increment);
switch (kind) {
case CTF_K_INTEGER:
case CTF_K_FLOAT:
vbytes = sizeof (uint_t);
break;
case CTF_K_ARRAY:
vbytes = sizeof (ctf_array_t);
break;
case CTF_K_FUNCTION:
vbytes = sizeof (ushort_t) * (vlen + (vlen & 1));
break;
case CTF_K_STRUCT:
case CTF_K_UNION:
if (fp->ctf_version == CTF_VERSION_1 ||
size < CTF_LSTRUCT_THRESH) {
ctf_member_t *mp = (ctf_member_t *)
((uintptr_t)tp + increment);
vbytes = sizeof (ctf_member_t) * vlen;
for (n = vlen; n != 0; n--, mp++)
child |= CTF_TYPE_ISCHILD(mp->ctm_type);
} else {
ctf_lmember_t *lmp = (ctf_lmember_t *)
((uintptr_t)tp + increment);
vbytes = sizeof (ctf_lmember_t) * vlen;
for (n = vlen; n != 0; n--, lmp++)
child |=
CTF_TYPE_ISCHILD(lmp->ctlm_type);
}
break;
case CTF_K_ENUM:
vbytes = sizeof (ctf_enum_t) * vlen;
break;
case CTF_K_FORWARD:
/*
* For forward declarations, ctt_type is the CTF_K_*
* kind for the tag, so bump that population count too.
* If ctt_type is unknown, treat the tag as a struct.
*/
if (tp->ctt_type == CTF_K_UNKNOWN ||
tp->ctt_type >= CTF_K_MAX)
pop[CTF_K_STRUCT]++;
else
pop[tp->ctt_type]++;
/*FALLTHRU*/
case CTF_K_UNKNOWN:
vbytes = 0;
break;
case CTF_K_POINTER:
case CTF_K_TYPEDEF:
case CTF_K_VOLATILE:
case CTF_K_CONST:
case CTF_K_RESTRICT:
child |= CTF_TYPE_ISCHILD(tp->ctt_type);
vbytes = 0;
break;
default:
ctf_dprintf("detected invalid CTF kind -- %u\n", kind);
return (ECTF_CORRUPT);
}
tp = (ctf_type_t *)((uintptr_t)tp + increment + vbytes);
pop[kind]++;
}
/*
* If we detected a reference to a child type ID, then we know this
* container is a child and may have a parent's types imported later.
*/
if (child) {
ctf_dprintf("CTF container %p is a child\n", (void *)fp);
fp->ctf_flags |= LCTF_CHILD;
} else
ctf_dprintf("CTF container %p is a parent\n", (void *)fp);
/*
* Now that we've counted up the number of each type, we can allocate
* the hash tables, type translation table, and pointer table.
*/
if ((err = ctf_hash_create(&fp->ctf_structs, pop[CTF_K_STRUCT])) != 0)
return (err);
if ((err = ctf_hash_create(&fp->ctf_unions, pop[CTF_K_UNION])) != 0)
return (err);
if ((err = ctf_hash_create(&fp->ctf_enums, pop[CTF_K_ENUM])) != 0)
return (err);
if ((err = ctf_hash_create(&fp->ctf_names,
pop[CTF_K_INTEGER] + pop[CTF_K_FLOAT] + pop[CTF_K_FUNCTION] +
pop[CTF_K_TYPEDEF] + pop[CTF_K_POINTER] + pop[CTF_K_VOLATILE] +
pop[CTF_K_CONST] + pop[CTF_K_RESTRICT])) != 0)
return (err);
fp->ctf_txlate = ctf_alloc(sizeof (uint_t) * (fp->ctf_typemax + 1));
fp->ctf_ptrtab = ctf_alloc(sizeof (ushort_t) * (fp->ctf_typemax + 1));
if (fp->ctf_txlate == NULL || fp->ctf_ptrtab == NULL)
return (EAGAIN); /* memory allocation failed */
xp = fp->ctf_txlate;
*xp++ = 0; /* type id 0 is used as a sentinel value */
bzero(fp->ctf_txlate, sizeof (uint_t) * (fp->ctf_typemax + 1));
bzero(fp->ctf_ptrtab, sizeof (ushort_t) * (fp->ctf_typemax + 1));
/*
* In the second pass through the types, we fill in each entry of the
* type and pointer tables and add names to the appropriate hashes.
*/
for (id = 1, tp = tbuf; tp < tend; xp++, id++) {
ushort_t kind = LCTF_INFO_KIND(fp, tp->ctt_info);
ulong_t vlen = LCTF_INFO_VLEN(fp, tp->ctt_info);
ssize_t size, increment;
const char *name;
size_t vbytes;
ctf_helem_t *hep;
ctf_encoding_t cte;
(void) ctf_get_ctt_size(fp, tp, &size, &increment);
name = ctf_strptr(fp, tp->ctt_name);
switch (kind) {
case CTF_K_INTEGER:
case CTF_K_FLOAT:
/*
* Only insert a new integer base type definition if
* this type name has not been defined yet. We re-use
* the names with different encodings for bit-fields.
*/
if ((hep = ctf_hash_lookup(&fp->ctf_names, fp,
name, strlen(name))) == NULL) {
err = ctf_hash_insert(&fp->ctf_names, fp,
CTF_INDEX_TO_TYPE(id, child), tp->ctt_name);
if (err != 0 && err != ECTF_STRTAB)
return (err);
} else if (ctf_type_encoding(fp, hep->h_type,
&cte) == 0 && cte.cte_bits == 0) {
/*
* Work-around SOS8 stabs bug: replace existing
* intrinsic w/ same name if it was zero bits.
*/
hep->h_type = CTF_INDEX_TO_TYPE(id, child);
}
vbytes = sizeof (uint_t);
break;
case CTF_K_ARRAY:
vbytes = sizeof (ctf_array_t);
break;
case CTF_K_FUNCTION:
err = ctf_hash_insert(&fp->ctf_names, fp,
CTF_INDEX_TO_TYPE(id, child), tp->ctt_name);
if (err != 0 && err != ECTF_STRTAB)
return (err);
vbytes = sizeof (ushort_t) * (vlen + (vlen & 1));
break;
case CTF_K_STRUCT:
err = ctf_hash_define(&fp->ctf_structs, fp,
CTF_INDEX_TO_TYPE(id, child), tp->ctt_name);
if (err != 0 && err != ECTF_STRTAB)
return (err);
if (fp->ctf_version == CTF_VERSION_1 ||
size < CTF_LSTRUCT_THRESH)
vbytes = sizeof (ctf_member_t) * vlen;
else {
vbytes = sizeof (ctf_lmember_t) * vlen;
nlstructs++;
}
break;
case CTF_K_UNION:
err = ctf_hash_define(&fp->ctf_unions, fp,
CTF_INDEX_TO_TYPE(id, child), tp->ctt_name);
if (err != 0 && err != ECTF_STRTAB)
return (err);
if (fp->ctf_version == CTF_VERSION_1 ||
size < CTF_LSTRUCT_THRESH)
vbytes = sizeof (ctf_member_t) * vlen;
else {
vbytes = sizeof (ctf_lmember_t) * vlen;
nlunions++;
}
break;
case CTF_K_ENUM:
err = ctf_hash_define(&fp->ctf_enums, fp,
CTF_INDEX_TO_TYPE(id, child), tp->ctt_name);
if (err != 0 && err != ECTF_STRTAB)
return (err);
vbytes = sizeof (ctf_enum_t) * vlen;
break;
case CTF_K_TYPEDEF:
err = ctf_hash_insert(&fp->ctf_names, fp,
CTF_INDEX_TO_TYPE(id, child), tp->ctt_name);
if (err != 0 && err != ECTF_STRTAB)
return (err);
vbytes = 0;
break;
case CTF_K_FORWARD:
/*
* Only insert forward tags into the given hash if the
* type or tag name is not already present.
*/
switch (tp->ctt_type) {
case CTF_K_STRUCT:
hp = &fp->ctf_structs;
break;
case CTF_K_UNION:
hp = &fp->ctf_unions;
break;
case CTF_K_ENUM:
hp = &fp->ctf_enums;
break;
default:
hp = &fp->ctf_structs;
}
if (ctf_hash_lookup(hp, fp,
name, strlen(name)) == NULL) {
err = ctf_hash_insert(hp, fp,
CTF_INDEX_TO_TYPE(id, child), tp->ctt_name);
if (err != 0 && err != ECTF_STRTAB)
return (err);
}
vbytes = 0;
break;
case CTF_K_POINTER:
/*
* If the type referenced by the pointer is in this CTF
* container, then store the index of the pointer type
* in fp->ctf_ptrtab[ index of referenced type ].
*/
if (CTF_TYPE_ISCHILD(tp->ctt_type) == child &&
CTF_TYPE_TO_INDEX(tp->ctt_type) <= fp->ctf_typemax)
fp->ctf_ptrtab[
CTF_TYPE_TO_INDEX(tp->ctt_type)] = id;
/*FALLTHRU*/
case CTF_K_VOLATILE:
case CTF_K_CONST:
case CTF_K_RESTRICT:
err = ctf_hash_insert(&fp->ctf_names, fp,
CTF_INDEX_TO_TYPE(id, child), tp->ctt_name);
if (err != 0 && err != ECTF_STRTAB)
return (err);
/*FALLTHRU*/
default:
vbytes = 0;
break;
}
*xp = (uint_t)((uintptr_t)tp - (uintptr_t)fp->ctf_buf);
tp = (ctf_type_t *)((uintptr_t)tp + increment + vbytes);
}
ctf_dprintf("%lu total types processed\n", fp->ctf_typemax);
ctf_dprintf("%u enum names hashed\n", ctf_hash_size(&fp->ctf_enums));
ctf_dprintf("%u struct names hashed (%d long)\n",
ctf_hash_size(&fp->ctf_structs), nlstructs);
ctf_dprintf("%u union names hashed (%d long)\n",
ctf_hash_size(&fp->ctf_unions), nlunions);
ctf_dprintf("%u base type names hashed\n",
ctf_hash_size(&fp->ctf_names));
/*
* Make an additional pass through the pointer table to find pointers
* that point to anonymous typedef nodes. If we find one, modify the
* pointer table so that the pointer is also known to point to the
* node that is referenced by the anonymous typedef node.
*/
for (id = 1; id <= fp->ctf_typemax; id++) {
if ((dst = fp->ctf_ptrtab[id]) != 0) {
tp = LCTF_INDEX_TO_TYPEPTR(fp, id);
if (LCTF_INFO_KIND(fp, tp->ctt_info) == CTF_K_TYPEDEF &&
strcmp(ctf_strptr(fp, tp->ctt_name), "") == 0 &&
CTF_TYPE_ISCHILD(tp->ctt_type) == child &&
CTF_TYPE_TO_INDEX(tp->ctt_type) <= fp->ctf_typemax)
fp->ctf_ptrtab[
CTF_TYPE_TO_INDEX(tp->ctt_type)] = dst;
}
}
return (0);
}
/*
* Attempt to convert the given C type name into the corresponding CTF type ID.
* It is not possible to do complete and proper conversion of type names
* without implementing a more full-fledged parser, which is necessary to
* handle things like types that are function pointers to functions that
* have arguments that are function pointers, and fun stuff like that.
* Instead, this function implements a very simple conversion algorithm that
* finds the things that we actually care about: structs, unions, enums,
* integers, floats, typedefs, and pointers to any of these named types.
*/
ctf_id_t
ctf_lookup_by_name(ctf_file_t *fp, const char *name)
{
static const char delimiters[] = " \t\n\r\v\f*";
const ctf_lookup_t *lp;
const ctf_helem_t *hp;
const char *p, *q, *end;
ctf_id_t type = 0;
ctf_id_t ntype, ptype;
if (name == NULL)
return (ctf_set_errno(fp, EINVAL));
for (p = name, end = name + strlen(name); *p != '\0'; p = q) {
while (isspace((unsigned char)*p))
p++; /* skip leading ws */
if (p == end)
break;
if ((q = strpbrk(p + 1, delimiters)) == NULL)
q = end; /* compare until end */
if (*p == '*') {
/*
* Find a pointer to type by looking in fp->ctf_ptrtab.
* If we can't find a pointer to the given type, see if
* we can compute a pointer to the type resulting from
* resolving the type down to its base type and use
* that instead. This helps with cases where the CTF
* data includes "struct foo *" but not "foo_t *" and
* the user tries to access "foo_t *" in the debugger.
*/
ntype = fp->ctf_ptrtab[CTF_TYPE_TO_INDEX(type)];
if (ntype == 0) {
ntype = ctf_type_resolve(fp, type);
if (ntype == CTF_ERR || (ntype = fp->ctf_ptrtab[
CTF_TYPE_TO_INDEX(ntype)]) == 0) {
(void) ctf_set_errno(fp, ECTF_NOTYPE);
goto err;
}
}
type = CTF_INDEX_TO_TYPE(ntype,
(fp->ctf_flags & LCTF_CHILD));
q = p + 1;
continue;
}
if (isqualifier(p, (size_t)(q - p)))
continue; /* skip qualifier keyword */
for (lp = fp->ctf_lookups; lp->ctl_prefix != NULL; lp++) {
if (lp->ctl_prefix[0] == '\0' ||
strncmp(p, lp->ctl_prefix, (size_t)(q - p)) == 0) {
for (p += lp->ctl_len; isspace((unsigned char)*p); p++)
continue; /* skip prefix and next ws */
if ((q = strchr(p, '*')) == NULL)
q = end; /* compare until end */
while (isspace((unsigned char)q[-1]))
q--; /* exclude trailing ws */
if ((hp = ctf_hash_lookup(lp->ctl_hash, fp, p,
(size_t)(q - p))) == NULL) {
(void) ctf_set_errno(fp, ECTF_NOTYPE);
goto err;
}
type = hp->h_type;
break;
}
}
if (lp->ctl_prefix == NULL) {
(void) ctf_set_errno(fp, ECTF_NOTYPE);
goto err;
}
}
if (*p != '\0' || type == 0)
return (ctf_set_errno(fp, ECTF_SYNTAX));
return (type);
err:
if (fp->ctf_parent != NULL &&
(ptype = ctf_lookup_by_name(fp->ctf_parent, name)) != CTF_ERR)
return (ptype);
return (CTF_ERR);
}
/*
* 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);
}
static int
write_type(void *arg1, void *arg2)
{
tdesc_t *tp = arg1;
ctf_buf_t *b = arg2;
elist_t *ep;
mlist_t *mp;
intr_t *ip;
size_t offset;
uint_t encoding;
uint_t data;
int isroot = tp->t_flags & TDESC_F_ISROOT;
int i;
ctf_type_t ctt;
ctf_array_t cta;
ctf_member_t ctm;
ctf_lmember_t ctlm;
ctf_enum_t cte;
ushort_t id;
ctlm.ctlm_pad = 0;
/*
* There shouldn't be any holes in the type list (where a hole is
* defined as two consecutive tdescs without consecutive ids), but
* check for them just in case. If we do find holes, we need to make
* fake entries to fill the holes, or we won't be able to reconstruct
* the tree from the written data.
*/
if (++b->nptent < CTF_TYPE_TO_INDEX(tp->t_id)) {
debug(2, "genctf: type hole from %d < x < %d\n",
b->nptent - 1, CTF_TYPE_TO_INDEX(tp->t_id));
ctt.ctt_name = CTF_TYPE_NAME(CTF_STRTAB_0, 0);
ctt.ctt_info = CTF_TYPE_INFO(0, 0, 0);
while (b->nptent < CTF_TYPE_TO_INDEX(tp->t_id)) {
write_sized_type_rec(b, &ctt, 0);
b->nptent++;
}
}
offset = strtab_insert(&b->ctb_strtab, tp->t_name);
ctt.ctt_name = CTF_TYPE_NAME(CTF_STRTAB_0, offset);
switch (tp->t_type) {
case INTRINSIC:
ip = tp->t_intr;
if (ip->intr_type == INTR_INT)
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_INTEGER,
isroot, 1);
else
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_FLOAT, isroot, 1);
write_sized_type_rec(b, &ctt, tp->t_size);
encoding = 0;
if (ip->intr_type == INTR_INT) {
if (ip->intr_signed)
encoding |= CTF_INT_SIGNED;
if (ip->intr_iformat == 'c')
encoding |= CTF_INT_CHAR;
else if (ip->intr_iformat == 'b')
encoding |= CTF_INT_BOOL;
else if (ip->intr_iformat == 'v')
encoding |= CTF_INT_VARARGS;
} else
encoding = ip->intr_fformat;
data = CTF_INT_DATA(encoding, ip->intr_offset, ip->intr_nbits);
if (target_requires_swap) {
SWAP_32(data);
}
ctf_buf_write(b, &data, sizeof (data));
break;
case POINTER:
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_POINTER, isroot, 0);
ctt.ctt_type = tp->t_tdesc->t_id;
write_unsized_type_rec(b, &ctt);
break;
case ARRAY:
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_ARRAY, isroot, 1);
write_sized_type_rec(b, &ctt, tp->t_size);
cta.cta_contents = tp->t_ardef->ad_contents->t_id;
cta.cta_index = tp->t_ardef->ad_idxtype->t_id;
cta.cta_nelems = tp->t_ardef->ad_nelems;
if (target_requires_swap) {
SWAP_16(cta.cta_contents);
SWAP_16(cta.cta_index);
SWAP_32(cta.cta_nelems);
}
ctf_buf_write(b, &cta, sizeof (cta));
break;
case STRUCT:
case UNION:
for (i = 0, mp = tp->t_members; mp != NULL; mp = mp->ml_next)
i++; /* count up struct or union members */
if (i > CTF_MAX_VLEN) {
terminate("sou %s has too many members: %d > %d\n",
tdesc_name(tp), i, CTF_MAX_VLEN);
}
if (tp->t_type == STRUCT)
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_STRUCT, isroot, i);
else
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_UNION, isroot, i);
write_sized_type_rec(b, &ctt, tp->t_size);
if (tp->t_size < CTF_LSTRUCT_THRESH) {
for (mp = tp->t_members; mp != NULL; mp = mp->ml_next) {
offset = strtab_insert(&b->ctb_strtab,
mp->ml_name);
ctm.ctm_name = CTF_TYPE_NAME(CTF_STRTAB_0,
offset);
ctm.ctm_type = mp->ml_type->t_id;
ctm.ctm_offset = mp->ml_offset;
if (target_requires_swap) {
SWAP_32(ctm.ctm_name);
SWAP_16(ctm.ctm_type);
SWAP_16(ctm.ctm_offset);
}
ctf_buf_write(b, &ctm, sizeof (ctm));
}
} else {
for (mp = tp->t_members; mp != NULL; mp = mp->ml_next) {
offset = strtab_insert(&b->ctb_strtab,
mp->ml_name);
ctlm.ctlm_name = CTF_TYPE_NAME(CTF_STRTAB_0,
offset);
ctlm.ctlm_type = mp->ml_type->t_id;
ctlm.ctlm_offsethi =
CTF_OFFSET_TO_LMEMHI(mp->ml_offset);
ctlm.ctlm_offsetlo =
CTF_OFFSET_TO_LMEMLO(mp->ml_offset);
if (target_requires_swap) {
SWAP_32(ctlm.ctlm_name);
SWAP_16(ctlm.ctlm_type);
SWAP_32(ctlm.ctlm_offsethi);
SWAP_32(ctlm.ctlm_offsetlo);
}
ctf_buf_write(b, &ctlm, sizeof (ctlm));
}
}
break;
case ENUM:
for (i = 0, ep = tp->t_emem; ep != NULL; ep = ep->el_next)
i++; /* count up enum members */
if (i > CTF_MAX_VLEN) {
warning("enum %s has too many values: %d > %d\n",
tdesc_name(tp), i, CTF_MAX_VLEN);
i = CTF_MAX_VLEN;
}
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_ENUM, isroot, i);
write_sized_type_rec(b, &ctt, tp->t_size);
for (ep = tp->t_emem; ep != NULL && i > 0; ep = ep->el_next) {
offset = strtab_insert(&b->ctb_strtab, ep->el_name);
cte.cte_name = CTF_TYPE_NAME(CTF_STRTAB_0, offset);
cte.cte_value = ep->el_number;
if (target_requires_swap) {
SWAP_32(cte.cte_name);
SWAP_32(cte.cte_value);
}
ctf_buf_write(b, &cte, sizeof (cte));
i--;
}
break;
case FORWARD:
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_FORWARD, isroot, 0);
ctt.ctt_type = 0;
write_unsized_type_rec(b, &ctt);
break;
case TYPEDEF:
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_TYPEDEF, isroot, 0);
ctt.ctt_type = tp->t_tdesc->t_id;
write_unsized_type_rec(b, &ctt);
break;
case VOLATILE:
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_VOLATILE, isroot, 0);
ctt.ctt_type = tp->t_tdesc->t_id;
write_unsized_type_rec(b, &ctt);
break;
case CONST:
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_CONST, isroot, 0);
ctt.ctt_type = tp->t_tdesc->t_id;
write_unsized_type_rec(b, &ctt);
break;
case FUNCTION:
i = tp->t_fndef->fn_nargs + tp->t_fndef->fn_vargs;
if (i > CTF_MAX_VLEN) {
terminate("function %s has too many args: %d > %d\n",
tdesc_name(tp), i, CTF_MAX_VLEN);
}
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_FUNCTION, isroot, i);
ctt.ctt_type = tp->t_fndef->fn_ret->t_id;
write_unsized_type_rec(b, &ctt);
for (i = 0; i < (int) tp->t_fndef->fn_nargs; i++) {
id = tp->t_fndef->fn_args[i]->t_id;
if (target_requires_swap) {
SWAP_16(id);
}
ctf_buf_write(b, &id, sizeof (id));
}
if (tp->t_fndef->fn_vargs) {
id = 0;
ctf_buf_write(b, &id, sizeof (id));
i++;
}
if (i & 1) {
id = 0;
ctf_buf_write(b, &id, sizeof (id));
}
break;
case RESTRICT:
ctt.ctt_info = CTF_TYPE_INFO(CTF_K_RESTRICT, isroot, 0);
ctt.ctt_type = tp->t_tdesc->t_id;
write_unsized_type_rec(b, &ctt);
break;
default:
warning("Can't write unknown type %d\n", tp->t_type);
}
debug(3, "Wrote type %d %s\n", tp->t_id, tdesc_name(tp));
return (1);
}
