int
mdb_ctf_type_iter(const char *object, mdb_ctf_type_f *cb, void *data)
{
ctf_file_t *fp;
mdb_tgt_t *t = mdb.m_target;
int ret;
type_iter_t ti;
if (object == MDB_CTF_SYNTHETIC_ITER)
fp = mdb.m_synth;
else
fp = mdb_tgt_name_to_ctf(t, object);
if (fp == NULL)
return (-1);
ti.ti_cb = cb;
ti.ti_arg = data;
ti.ti_fp = fp;
if ((ret = ctf_type_iter(fp, type_iter_cb, &ti)) == CTF_ERR)
return (set_errno(ctf_to_errno(ctf_errno(fp))));
return (ret);
}
/*
* Check to see if there is ctf data in the given object. This is useful
* so that we don't enter some loop where every call to lookup fails.
*/
int
mdb_ctf_enabled_by_object(const char *object)
{
mdb_tgt_t *t = mdb.m_target;
return (mdb_tgt_name_to_ctf(t, object) != NULL);
}
int
nm_symbol_iter(const char *object, uint_t which, uint_t type,
mdb_tgt_sym_f *cb, nm_iter_info_t *niip)
{
mdb_tgt_t *t = mdb.m_target;
if (object == MDB_TGT_OBJ_EVERY) {
nm_object_iter_t noi;
noi.noi_which = which;
noi.noi_type = type;
noi.noi_cb = cb;
noi.noi_niip = niip;
return (mdb_tgt_object_iter(t, nm_object_iter_cb, &noi));
}
niip->nii_fp = mdb_tgt_name_to_ctf(t, object);
return (mdb_tgt_symbol_iter(t, object, which, type, cb, niip));
}
/*ARGSUSED*/
static int
obj_lookup(void *data, const mdb_map_t *mp, const char *name)
{
tnarg_t *tnp = data;
ctf_file_t *fp;
ctf_id_t id;
if ((fp = mdb_tgt_name_to_ctf(tnp->tn_tgt, name)) != NULL &&
(id = ctf_lookup_by_name(fp, tnp->tn_name)) != CTF_ERR) {
tnp->tn_fp = fp;
tnp->tn_id = id;
/*
* We may have found a forward declaration. If we did, we'll
* note the ID and file pointer, but we'll keep searching in
* an attempt to find the real thing. If we found something
* real (i.e. not a forward), we stop the iteration.
*/
return (ctf_type_kind(fp, id) == CTF_K_FORWARD ? 0 : -1);
}
return (0);
}
/*
* Convert a string type name with an optional leading object specifier into
* the corresponding CTF file container and type ID. If an error occurs, we
* print an appropriate message and return NULL.
*/
static ctf_file_t *
name_to_type(mdb_tgt_t *t, const char *cname, ctf_id_t *idp)
{
const char *object = MDB_TGT_OBJ_EXEC;
ctf_file_t *fp = NULL;
ctf_id_t id;
tnarg_t arg;
char *p, *s;
char buf[MDB_SYM_NAMLEN];
char *name = &buf[0];
(void) mdb_snprintf(buf, sizeof (buf), "%s", cname);
if ((p = strrsplit(name, '`')) != NULL) {
/*
* We need to shuffle things around a little to support
* type names of the form "struct module`name".
*/
if ((s = strsplit(name, ' ')) != NULL) {
bcopy(cname + (s - name), name, (p - s) - 1);
name[(p - s) - 1] = '\0';
bcopy(cname, name + (p - s), s - name);
p = name + (p - s);
}
if (*name != '\0')
object = name;
name = p;
}
/*
* Attempt to look up the name in the primary object file. If this
* fails and the name was unscoped, search all remaining object files.
* Finally, search the synthetic types.
*/
if (((fp = mdb_tgt_name_to_ctf(t, object)) == NULL ||
(id = ctf_lookup_by_name(fp, name)) == CTF_ERR ||
ctf_type_kind(fp, id) == CTF_K_FORWARD) &&
object == MDB_TGT_OBJ_EXEC) {
arg.tn_tgt = t;
arg.tn_name = name;
arg.tn_fp = NULL;
arg.tn_id = CTF_ERR;
(void) mdb_tgt_object_iter(t, obj_lookup, &arg);
if (arg.tn_id != CTF_ERR) {
fp = arg.tn_fp;
id = arg.tn_id;
} else if (mdb.m_synth != NULL) {
if ((id = ctf_lookup_by_name(mdb.m_synth,
name)) != CTF_ERR)
fp = mdb.m_synth;
}
}
if (fp == NULL)
return (NULL); /* errno is set for us */
if (id == CTF_ERR) {
(void) set_errno(ctf_to_errno(ctf_errno(fp)));
return (NULL);
}
*idp = id;
return (fp);
}
